那些有关求解next数组的算法

next数组的历史

　　有关字符串的模式匹配算法中，比较容易写出的是朴素的匹配算法也就是一种暴力求解方式，但是由于其时间复杂度为子串长度和主串长度的乘积，例如strlen(subStr) = n,strlen(mainStr) = m,则其时间复杂度为O(mn)。

　　为了能够得到更有效的匹配算法，D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特--莫里斯--普拉特操作(简称KMP算法)。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。这也即是KMP算法的设计思想。

next数组的求解思路

　　求next数组，next[j]表示，当模式串j位置与主串i位置处发生不匹配时，i指针不回溯，j指针回溯到next[j]的位置。

　　对于求next[j]有三种情况：

1、j = 0时，next[j] = -1;//即模式串的第一个字符与主串i位置发生不匹配，应将i跳过当前位置，从下一个位置和模式串的第一个字符继续比较。

2、假设已知next[j] = k,即subStr[0,...,k-1] = subStr[j-k,j-1]。当subStr[k] = subStr[j]时，也就是说模式串满足subStr[0,...,k] = subStr[j-k,j]，可以得知next[j+1] = k + 1 = next[j] + 1;

3、当subStr[k] != subStr[j]时，就需要从k位置之前去查找与subStr[j]匹配的位置，假设为j'。这样问题又可以转化为第二种情况，即next[j+1] = next[j'] + 1 = k' + 1。

三种求解next数组的算法

　　但是如何去求解next数组呢？有关这个问题，我思考了很长时间，下面给出几种算法：

　　算法一，严格根据next数组的定义：

 void getNext(char subStr[],int next[])
 {
     int i = , j = i - ,k = -;
     next[] = -;
     while (i < strlen(subStr))
     {
         //k = -1时表示j指针回溯到第一个字符的位置
         //subStr[k] == subStr[i-1]表示第k个字符和i - 1个字符相等，属于情况二
         if (k == - || subStr[k] == subStr[i-])
         {
             next[i] = k + ;
             k = next[i];
             i++;
         }
         //情况三，不相等的话，要回溯j指针，subStr[j'] = subStr[i-1]的位置j'
         else
         {
             int t = i - ;
             while (t>=)
             {
                 if (subStr[t] == subStr[i - ])
                 {
                     j = t;
                     break;
                 }
                 t--;
             }
             if (t < )
                 j = ;
             k = next[j];
         }
 
     }
 }

　　算法二，算法的设计思想和算法一大致相同

void getNext(const char P[], int next[])
{
    int q, k;
    int m = strlen(P);
    next[] = -;//模版字符串的第一个字符的最大前后缀长度为0
    for (q = ; q < m; ++q)//for循环，从第二个字符开始，依次计算每一个字符对应的next值
    {
        k = next[q - ];
        while (k >  && P[q - ] != P[k])//迭代地求出P[0]···P[q]的最大的相同的前后缀长度k
        {
            k--;
        }
 
        if (P[q-] == P[k])//如果相等，那么最大相同前后缀长度加1
        {
            k++;
        }
        if (k == -)
            k = ;
        next[q] = k;
 
    }
}

　　算法三，更加优化的求解next数组的算法

void getNext(const char subStr[], int next[])
{
    int i = , j = -;
    next[] = -;
    while (i < strlen(subStr))
    {
                //i从0开始的，属于情况二
                //j是前后缀长度
        if (j == - || subStr[i] == subStr[j])
        {
            i++;
            j++;
            next[i] = j;
        }
                //情况三，不同则j指针回溯
        else
            j = next[j];
    }
}

　　现在来进行总结一下，对于算法一和算法二来说，它们的时间复杂度是一样的，但是相对于算法三来说，虽然不如算法三高效，但是比较容易理解！

PS：如果有误的地方，请指出，共同进步！