KMP算法

KMP算法的核心就是求next数组，求next数组最先想到的就是暴力遍历，如果是暴力遍历的话，最初的位置next[0]=-1，然后第二个开始，第j个数，就要判断前j-1能不能是前后缀

void GetNext(int next[])
{
    next[0]=-1;
    int i,j,k;
    bool flag=1;
    for(i=1;i<T.length();i++)
    {
        flag=1;
        for(j=i-2;j>=0;j--)
        {
            for(k=0;k<=j;k++)
                if(T[k]!=T[i-1-j+k])
                {
                    flag=0;
                    break;
                }
            if(flag==1)
            {
                next[i]=j+1;
                break;
            }
            else
            flag=1; 
        }
    }
}

但是这样就是一个三次方的时间复杂度，应该想办法优化这个算法。

优化就是利用前面已经算好的数据，next[0]=-1这个不用算，然后从next[i]来看，假设next[i]=k，这就说明0~k-1个数是有对应后缀的，那么就要比较next[k]和next[j]，如果相等，自然就是next[j]=k+1，如果不相等，就说明next[j]的值肯定是小于k的，那么就需要减少“k”的数值，就是要利用next[j-1]的最大前后缀

void GetNext2(int next[])
{
    next[0]=-1;
    next[1]=0;
    int i;
    for(i=2;i<T.length();i++)
    {
        int k=next[i-1];
        while(k!=-1)
        {
            if(T[k]==T[i-1])
            {
                next[i]=k+1;
                break;
            }
            else
                k=next[k];
        }
        next[i]=0;
    }
} 

这个代码的复杂度就基本上可以讲到O（n）