字符串的匹配 KMP算法分析

图片来源于土豆洋芋山药蛋 https://blog.csdn.net/qq_33414271/article/details/83789478

1.什么是KMP算法？

在主串Str中查找模式串Pattern的方法中，有一种方式叫KMP算法

KMP算法是在模式串字符与主串字符匹配失配时，利用已经匹配的模式串字符子集的最大块对称性，让模式串尽量后移的算法。

2. 暴力匹配算法

假设现在我们面临这样一个问题：有一个文本串S，和一个模式串P，现在要查找P在S中的位置，怎么查找呢？

如果用暴力匹配的思路，并假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。

代码如下：

#include<bits/stdc++.h>
#include<algorithm>
#include<math.h>
#include<vector>
#define inf 1e6
using namespace std;
char s[1000],t[1000];
int ViolentPipei(char *s,char *t) // 暴力匹配
{
int slen=strlen(s);
int tlen=strlen(t);
int i=0,j=0;
while(i<slen&&j<tlen)
{
if(s[i]==t[j])
i++,j++;
else
i=i-j+1,j=0;
}
if(j==tlen)
return i-j;
else
return -1;
}
int main()
{
cin>>s>>t;
cout<<ViolentPipei(s,t)<<endl;
return 0;
}

举个例子

如果给定文本串S“BBC ABCDAB ABCDABCDABDE”，和模式串P“ABCDABD”，现在要拿模式串P去跟文本串S匹配，整个过程如下所示：

1. S[0]为B，P[0]为A，不匹配，执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[1]跟P[0]匹配，相当于模式串要往右移动一位（i=1，j=0）

2. S[1]跟P[0]还是不匹配，继续执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[2]跟P[0]匹配（i=2，j=0），从而模式串不断的向右移动一位（不断的执行“令i = i - (j - 1)，j = 0”，i从2变到4，j一直为0）

扫描二维码关注公众号，回复： 4148102 查看本文章

3. 直到S[4]跟P[0]匹配成功（i=4，j=0），此时按照上面的暴力匹配算法的思路，转而执行第①条指令：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，可得S[i]为S[5]，P[j]为P[1]，即接下来S[5]跟P[1]匹配（i=5，j=1）

4. S[5]跟P[1]匹配成功，继续执行第①条指令：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此进行下去

5. 直到S[10]为空格字符，P[6]为字符D（i=10，j=6），因为不匹配，重新执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，相当于S[5]跟P[0]匹配（i=5，j=0）

6. 至此，我们可以看到，如果按照暴力匹配算法的思路，尽管之前文本串和模式串已经分别匹配到了S[9]、P[5]，但因为S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，从而让S[5]跟P[0]匹配。

而S[5]肯定跟P[0]失配。为什么呢？因为在之前第4步匹配中，我们已经得知S[5] = P[1] = B，而P[0] = A，即P[1] != P[0]，故S[5]必定不等于P[0]，所以回溯过去必然会导致失配。那有没有一种算法，让i 不往回退，只需要移动j 即可呢？

答案是肯定的。这种算法就是本文的主旨KMP算法，它利用之前已经部分匹配这个有效信息，保持i 不回溯，通过修改j 的位置，让模式串尽量地移动到有效的位置。

3. KMP算法

3.1 定义

Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P 的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法。

假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置
如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]。此举意味着失配时，模式串P相对于文本串S向右移动了j - next [j] 位。
换言之，当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值（next 数组的求解会在下文的3.3.3节中详细阐述），即移动的实际位数为：j - next[j]，且此值大于等于1。
很快，你也会意识到next 数组各值的含义：代表当前字符之前的字符串中，有多大长度的相同前缀后缀。例如如果next [j] = k，代表j 之前的字符串中有最大长度为k 的相同前缀后缀。

此也意味着在某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串应该跳到哪个位置（跳到next [j] 的位置）。如果next [j] 等于0或-1，则跳到模式串的开头字符，若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某个字符，而不是跳到开头，且具体跳过了k 个字符。

代码为：

int KmpSearch(char* s, char* p)
{
   int i = 0;
   int j = 0;
   int sLen = strlen(s);
   int pLen = strlen(p);
   while (i < sLen && j < pLen)
   {
       //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++
       if (j == -1 || s[i] == p[j])
       {
           i++;
           j++;
       }
       else
       {
           //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]
           //next[j]即为j所对应的next值
           j = next[j];
       }
   }
   if (j == pLen)
       return i - j;
   else
       return -1;
}

.........综上所述，得到next()数组代码：

void GetNext(char* p,int next[])
{
   int pLen = strlen(p);
   next[0] = -1;
   int k = -1;
   int j = 0;
   while (j < pLen - 1)
   {
       //p[k]表示前缀，p[j]表示后缀
       if (k == -1 || p[j] == p[k])
       {
           ++k;
           ++j;
           next[j] = k;
       }
       else
       {
           k = next[k];
       }
   }
}

修改后的next()数组代码：

//优化过后的next 数组求法
void GetNextval(char* p, int next[])
{
   int pLen = strlen(p);
   next[0] = -1;
   int k = -1;
   int j = 0;
   while (j < pLen - 1)
   {
       //p[k]表示前缀，p[j]表示后缀
       if (k == -1 || p[j] == p[k])
       {
           ++j;
           ++k;
           //较之前next数组求法，改动在下面4行
           if (p[j] != p[k])
               next[j] = k; //之前只有这一行
           else
               //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
               next[j] = next[k];
       }
       else
       {
           k = next[k];
       }
   }
}
............KMP算法如下：