算法笔记--KMP模式匹配算法

看完数据结构，串这一章之后，对其中的kmp算法，感觉总是模凌两可的感觉，有一种将要入门却不知道该脉哪只脚的感觉，想把自己的理解写出来，求大佬们指点一下。

下面所提到的字符串都是基于如下的字符串定义：

#define MAXSIZE 15
struct String{
    char data[MAXSIZE];
    int length;
}a = {"goodgoogle",10},b ={ "google",6};

字符串数组从0开始存储字符。

朴素模式匹配算法

算法思路：
1.设置两个指针i，j，分别指向主串S和模式串T。
2.依次比较S[i]与T[j]，如果S[i] = T[j],则分别++i，++j。
3.如果S[i] ！= T[j]，那么i始终返回到S最先开始匹配的位置的下一个元素，j始终返回0；
4.直到 j > T.length,返回 i - j.
代码如下：

int index(string s,string t,int pos){
    int i = pos;//表示主串s起始位置
    int j = 0; //子串t的起始位置
    while(s[i] != '\0' && t[j] != '\0'){
        if(s[i] == t[j]){//如果相等就向后移一位
            ++i;
            ++j;
        }
        else {
            i = i- j + 1 ;//如果第一位是存储的字符长度，就是i=i-j+2
            j = 0;
        }
        if(t[j] == '\0')
            return i-j;
    }
    return 0;
}

但是这个算法有一个缺点，如果失配元素的位置在T的末尾的话，就会造成很多次多余的匹配。而kmp算法就是为了解决这一问题的。

kmp算法

核心思路：
1.用一个next数组来存放当前元素失配的情况下，前缀后缀最大共同字符数，next[j].
例如：

T串在D之前，next[j] = next[6] = 2.
2.为了避免朴素匹配算法重复匹配的缺点，提出不再移动主串S的指针i，只移动子串T，使 j = next[j]。
3.在求前缀后缀最大共同字符数next[j]的时候，也可以看做是一次匹配的过程，也就是前缀和后缀匹配的过程，前缀作为主串，后缀作为子串，去找最长共同元素串。
代码如下

void Getnext(int next[],String t)
{
    int j=0;//当前元素的下标，后缀单个字符的下标
    int k=-1;//当前元素之前有多少个相同元素，同时也做前缀单个字符的下标
    next[0]=-1;//特殊标记
    while(j<t.length-1)
    {
        if(k == -1 || t.data[j] == t.data[k])
        {
            j++;
            k++;
            next[j] = k;
        }
        else
            k = next[k];//不等就重新匹配。
    }
}
int KMP(String s,String t,int pos)
{
    int next[MAXSIZE],i=pos,j=0;
    Getnext(next,t);
    while(i<s.length && j<t.length)
    {
        if(j==-1 || s.data[i]==t.data[j])
        {
            i++;
            j++;
        }
        else
            j=next[j];               //j回退。。。
    }
    if(j>=t.length)
        return (i-t.length);         //匹配成功，返回子串的位置
    else
        return (-1);                  //没找到
}

关于next数组的求法：
设当前失配的元素下标为：j，next[j] = k;
也就是说

现在要求next【j+1】，实际上就是判断Pk等不等于Pj
如果Pk = Pj，那么next[j+1] = next[j]+1.
如果Pk != Pj,因为next数组的意义是子串中前缀后缀公共字符串最大数目，所以Pk！=Pj的时候，继续采取kmp算法的回退方法，将k = next[k]，从而去找到一个最长的匹配字段，也就是去寻找一个P[next[k]] = P[j].
即

如果K = next[k]，任然无法找到一个P[next[k]] = P[j]，就递归的进行下去，直到找到一个P[next[k]] = P[j]。

其他需要注意的地方：
next数组的第一个元素，是作为一个标记符号，记为-1，因为子串第一个元素永远没有最长公共前缀后缀。
所以k和j有可能等于-1，在求next数组的函数与kmp的函数中，判断条件应该各自加上j = =-1， k==-1。