关于《数据结构》课本KMP算法的理解

 

数据结构课上讲的KMP算法和我在ACM中学习的KMP算法是有区别的，这里我对课本上的KMP算法给出我的一些想法。

原理和之前的KMP是一样的https://www.cnblogs.com/wkfvawl/p/9768729.html，但是不同点在于之前的KPM中next数组存放的是到了该位时最大前后缀长度，而这里的KMP中next数组存放的是j下一步需要移动的位置。

个人觉得课本上的KMP算法强调位置，模式串上指针位置j,主串指针位置i,对于位置上的变化，更利于理解代码。

先贴出代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
void getNext(char *p,int *next)
{
    int j,k;
    next[1]=0;
    j=1;
    k=0;
    while(j<strlen(p)-1)
    {
        if(k==0||p[j]==p[k])    //匹配的情况下,p[j]==p[k]，next[j+1]=k+1;
        {
            j++;
            k++;
            next[j]=k;
        }
        else                   //p[j]!=p[k]，k=next[k]
        {
            k=next[k];
        }
    }
}
int kmp(char *s,char *p,int *next)
{
    int i=1,j=1;
    while(i<=strlen(s)&&j<=strlen(p))
    {
        if(j==0||s[i]==p[j])
        {
            i++;
            j++;
        }
        else
        {
            j=next[j];
        }
    }
    if(j>strlen(p))
    {
        return i-strlen(p);///匹配成功，返回存储位置
    }
    else
    {
        return 0;
    }
}

int main()
{
    int next[100],ans;
    char s[20]="ababcabcacbab";
    char p[10]="abcac";
    getNext(p,next);
    ans=kmp(s,p,next);
    printf("%d\n",ans);
    return 0;
}

 

 

“利用已经部分匹配这个有效信息，保持i指针不回溯，通过修改　j　指针，让模式串尽量地移动到有效的位置。”

 

所以，整个KMP的重点就在于当某一个字符与主串不匹配时，我们应该知道　j　指针要移动到哪？

接下来我们自己来发现j的移动规律：

如图：C和B不匹配了，我们要把　j　移动到哪？显然是第1位。为什么？因为前面有一个A相同啊：

如下图也是一样的情况：

 

可以把　j　指针移动到第2位，因为前面有两个字母是一样的：

 

至此我们可以大概看出一点端倪，当匹配失败时，j要移动的下一个位置　k。

存在着这样的性质：

最前面的k个字符和　j　之前的最后k个字符是一样的。

如果用数学公式来表示是这样的

P[0 ~ k-1] == P[j-k ~ j-1]

这个相当重要，如果觉得不好记的话，可以通过下图来理解：

 

弄明白了这个就应该可能明白为什么可以直接将　j　移动到　k　位置了。

因为:

当T[i] != P[j]时

有T[i-j ~ i-1] == P[0 ~ j-1]

由P[0 ~ k-1] == P[j-k ~ j-1]

必然：T[i-k ~ i-1] == P[0 ~ k-1]

 

这里我们回忆一下，之前那种KMP算法也是需要移动的， 移动位数 = 已匹配的字符数 - 对应的部分匹配值，已匹配的字符数就是移动到的j位置，而对应的部分匹配值就是前k个字符，一相减得到的不就是k位置吗？

 

好，接下来就是重点了，怎么求这个（这些）k呢？

因为在P的每一个位置都可能发生不匹配，也就是说我们要计算每一个位置　j　对应的k，所以用一个数组next来保存。

 

先看看next数据值的求解方法

  位序       1   2   3   4   5   6   7   8   9   
模式串     a   b   a   a   b   c   a   b   c   
 next值     0   1   1   2   2   3   1   2   3  

 

next数组的求解方法是：
1.第一位的next值为0
2.第二位的next值为1
后面求解每一位的next值时，根据前一位进行比较
3.第三位的next值：第二位的模式串为b ,对应的next值为1;将第二位的模式串b与第一位的模式串a进行比较，不相等；则第三位的next值为1(其他情况均为1)
4.第四位的next值：第三位的模式串为a ,对应的next值为1;将第三位的模式串a与第一位的模式串a进行比较，相同，则第四位的next值得为1+1=2
5.第五位的next值：第四位的模式串为a，对应的next值为2;将第四位的模式串a与第二位的模式串b进行比较，不相等；第二位的b对应的next值为1,则将第四位的模式串a与第一位的模式串a进行比较，相同，则第五位的next的值为1+1=2
6.第六位的next值：第五位的模式串为b，对应的next值为2;将第五位的模式串b与第二位的模式中b进行比较，相同，则第六位的next值为2+1=3
7.第七位的next值：第六位的模式串为c，对应的next值为3;将第六位的模式串c与第三位的模式串a进行比较，不相等；第三位的a对应的next值为1，
则将第六位的模式串c与第一位的模式串a进行比较，不相同，则第七位的next值为1(其他情况)
8.第八位的next值：第七位的模式串为a，对应的next值为1;将第七位的模式串a与第一位的模式串a进行比较，相同，则第八位的next值为1+1=2
9.第八位的next值：第八位的模式串为b，对应的next值为2;将第八位的模式串b与第二位的模式串b进行比较，相同，则第九位的next值为2+1=3
如果位数更多，依次类推

 

 

  

 

 

请仔细对比这两个图。

我们发现一个规律：

当P[k] == P[j]时，

有next[j+1] == next[j] + 1

其实这个是可以证明的：

因为在P[j]之前已经有P[0 ~ k-1] == p[j-k ~ j-1]。（next[j] == k）

这时候现有P[k] == P[j]，我们是不是可以得到P[0 ~ k-1] + P[k] == p[j-k ~ j-1] + P[j]。

即：P[0 ~ k] == P[j-k ~ j]，即next[j+1] == k + 1 == next[j] + 1。

这里的公式不是很好懂，还是看图会容易理解些。

那如果P[k] != P[j]呢？比如下图所示：

 

像这种情况，如果你从代码上看应该是这一句：k = next[k];为什么是这样子？你看下面应该就明白了。

 

现在你应该知道为什么要k = next[k]了吧！像上边的例子，我们已经不可能找到[ A，B，A，B ]这个最长的后缀串了，但我们还是可能找到[ A，B ]、[ B ]这样的前缀串的。所以这个过程像不像在定位[ A，B，A，C ]这个串，当C和主串不一样了（也就是k位置不一样了），那当然是把指针移动到next[k]啦。

 

void getNext(char *p,int *next)  
{  
    int j,k;  
    next[1]=0;  
    j=1;  
    k=0;  
    while(j<strlen(p)-1)  
    {  
        if(k==0||p[j]==p[k])    //匹配的情况下,p[j]==p[k]，next[j+1]=k+1;  
        {  
            j++;  
            k++;  
            next[j]=k;  
        }  
        else                   //p[j]!=p[k]，k=next[k]  
            k=next[k];  
    }  
}  

 

关于KMP算法的改进：

其实，前面定义的next[]数组是有一定缺陷的，下面进行举例：

 

 

 

  如上图，如果按照之前的方法所获取的next[]数组的话，当两个字符串匹配到上图的情况是，将会出现如下图的情况：

  我们发现，从step1到step3所走的路都是浪费的，因为都是用同一个字母(a)和b去比，而这个计算机也是很容易识别的，所以对于

next[]的改进是行的通的。

  究其原因，为什么我会说上面的3个步骤是白走的呢，以为这是三个连续的相等的a，因此我们可以从第一步直接跳到第四步，即：得到的数组next[j] = k，而模式串p[j] = p[k]，当主串中的s[i] 和 p[j] 匹配失败时，不需要再和p[k]比较，而直接和p[next[k]]进行比较，当然可以一直迭代往前。

即：

 

代码如下:

 

void get_nextval(char *p,int *next)
{
    int j,i;
    next[1]=0;
    i=1;
    j=0;
    while(i<strlen(p))
    {
        if(k==0||p[i]==p[j])
        {
            i++;
            j++;
            if(p[i]!=p[j])
            {
                nextval[i]=j;
            }
            else
            {
                nextval[i]=nextval[j];
            }
        }
        else
        {
            j=nextval[j];
        }
    }
}

 

关于这里的KMP算法中next数组和之前那种KMP算法中next数组的关系。

既然原理是相同的，这两者必然有一定的联系，我们姑且称最长公共前后缀的那个next为maxl

 

序号：    1     2     3     4     5     6     7     8

               a     b     a     a     b     c     a     c

maxl       0     0     1     1     2     0     1     0

next       0     1     1     2     2     3     1     2       ///接下来我们将maxl数组复制一行，去掉最后一个值，在开头加上一个-1，往右平移一位。每个值在+1。得到next数组。

nextval  0     1     0     2     1     3     0     2      ///按序号检查maxl和next的值是否相等，若不相等nextval的值为next的值；若相等，填入对应序号为next值的nextval值。

 

果然是有着关系的，最长公共前后缀对我来说是比较好理解的，这种方法能够较快的写出next数组。