KMP算法

        1，## KMP算法的来源？ ##

由于朴素匹配算法非常低效，需要挨个遍历主串，所以有三位前辈，D.E.Knuth，J.H.Morris，和V.R.Pratt发表了一个模式匹配算法，可以大大避免重复遍历的情况，我们称这为克努特–莫里斯–普拉特算法，简称KMP算法。

        2，## 何为KMP算法？ ##

KMP算法在匹配过程中发生失配时，并不是简单的从原始串的下一个字符重新开始匹配，而是根据匹配过程中所得到的信息跳过不必要的匹配，从而达到高效的匹配算法。
下图主串为S串abcabcabcd，匹配串为T串abcabcd

当第一次匹配到S[6]!=T[6]时，主串不回溯，匹配串没有回溯到回0位置，而是回溯到下标为3的位置，继续匹配，直到匹配完成。

那为何匹配串会回溯到下标为3的位置呢？实际上KMP匹配算法实现了一个next数组，匹配串回溯到next数组对应下标所存储的位置，此时next[6] = 3。

        3，## next数组的定义及计算 ##

(1),next数组的定义
next数组：存储的是匹配串匹配失败时回溯的位置
对于匹配串而言，满足匹配串中存在两个真子串相等，一个从0位置开始，一个以j-1位置结束，j为当前访问匹配串的下标，满足的公式是p0…pk-1 == pj-k..pj-1；k为next数组j下标所保存的值。

(2),next数组的计算
令next[0] = -1；next[1] = 0；next[j] = fun(next[j-1]);
根据p0…pk-1 = pj-k…pj-1公式可以求的，当next[j] = k；
next[j+1] 的值 就可以分为两种情况
if(pk == pj) next[j+1] = k+1; p0…pk = pj-k…pj
此时的pk就相当于sub[k]，而pj也就相当于sub[j]

if(pk != pj) k = next[k] ,然后在判断pk与pj是否相等

如果pk与pj一直不相等，直到k=-1，那就让它执行next[j+1] = 0； 无相等的匹配串，直接回溯到匹配串的第一位

p[j] != p[k] 直到 k = -1，不能在回退了。

            4，## next数组代码实现 ##              

思路 ： 用next[j]求next[j+1]，依此类推

void get_next(char *sub,int *next,int length)
{
    assert(sub != NULL && next != NULL);
    if(length < 1)
        return;

    next[0] = -1;
    next[1] = 0;
    int j = 1;  通过next[j] 计算 next[j+1]
    int k = 0;
    while(j < length - 1)
    {
            if(k == -1 || sub[k] == sub[j])  //如果相等，next数组++,如果k==-1，让sub[j+1] = 0；回溯到0位置
            {
                next[++j] = ++k;
            }
            else
            {
                k = next[k];
            }
    }    
}

            5，## KMP算法代码实现 ##

思路 ： KMP匹配算法实现了一个next数组，
在匹配的时候主串不回溯，匹配串回溯到next数组
对应下标所存储的位置，然后继续进行匹配，
直到匹配完毕。

int KMP(const char *str, const char* sub)
{
    if(str == NULL || sub == NULL)
        return -1;
    int str_len = strlen(str);
    int sub_len = strlen(sub);

    if(sub_len > str_len || sub_len == 0)
        return -1;
    int next[255];
    get_next(sub,next,sub_len); //得到next数组

    int i = 0;
    int j = 0;
    while(i < str_len && j < sub_len)
    {
        //当j等于-1时，说明不匹配，主串后移，匹配串j++到0位置，继续匹配，直到匹配完毕
        if(j == -1 || str[i] == sub[j]) //相等同时后移  
        {
            ++i;
            ++j
        }
        else
        {
            j = next[j]; //匹配串回溯到next数组所存储的位置
        }
    }
    if(j >= sub_len)
        return i - j;
    return -1;
}

//测试一下 代码
int main()
{
    char *str = "ababababc";
    char *sub = "ababc";
    int k = KMP(str,sub);
    printf("%d\n",k);
    return 0;
}

结果显示：从第四位开始匹配上了，例子很多，我这就只举一个啦，接下来让我看看KMP的时间复杂度。

        6，## KMP算法的时间复杂度 ##

对于主串的长度为m，匹配串的长度为n，进行匹配，KMP的时间复杂度为O(m+n)，相比于BF算法时间复杂度O(m*n)效率已经是提高的很多了。
对于KMP算法的优化，可以选择去优化next数组来实现，有兴趣的码友可以自己实现一下。