之前看到数据结构中字符串的模式匹配时，花了半天的时间，才把KMP算法中的next函数整明白了，结果过了几天在看到这时，只记得next[j+1]=next[j]+1，可是有时候能套公式正确算出，有时候就算不对，所以今天再重新理一遍思路，顺便记录下来，防止哪天脑子再短路了，又不知道怎么求解的了。

   根据定义next[1]=0，假设next[j]=k, 即P[1...k-1]==P[j-k,j-1]

   因此可以这样去实现：

[cpp] view plain copy

 

1. void getNext(char *p,int *next)  
2. {  
3.     int j,k;  
4.     next[1]=0;  
5.     j=1;  
6.     k=0;  
7.     while(j<strlen(p)-1)  
8.     {  
9.         if(k==0||p[j]==p[k])    //匹配的情况下,p[j]==p[k]，next[j+1]=k+1;  
10.         {  
11.             j++;  
12.             k++;  
13.             next[j]=k;  
14.         }  
15.         else                   //p[j]!=p[k]，k=next[k]  
16.             k=next[k];  
17.     }  
18. }  

KMP模式匹配算法改进：

       后来有人发现其实KMP算法还是有缺陷的，比如主串S=“aaaabcde”，子串T=“aaaaag”，其next数组为012345；当i=5 ，j=5是“b”与“a”不匹配，此时j=next[5]=4，又发现j=4时，“b”与“a”不匹配，依次类推，直到j=next[1]=0;此时i++，j++，i=6，j=1从而我们发现中间有多余的判断，由于子串T中第2、3、4、5位置的字符都与首位的“a”相同，即可以用首位next[1]的值去取代与它字符相等的后续next[j]的值，即next数组改为000005，此时由i=5，j=5时“b”与“a”不匹配，此时j=next[5]=0；此时i++，j++得到i=6，j=1，即可省去中间的多余判断。因此我们需要改进next函数的求解方法。

[cpp] view plain copy

 

1. /* 求模式串T的next函数修正值并存入数组nextval */  
2. void get_nextval(String T, int *nextval)   
3. {  
4.     int i,j;  
5.     i=1;  
6.     j=0;  
7.     nextval[1]=0;  
8.     while (i<T[0])  /* 此处T[0]表示串T的长度 */  
9.     {  
10.         if(j==0 || T[i]== T[j])     /* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */  
11.     {  
12.                 ++i;    
13.                 ++j;    
14.         if (T[i]!=T[j])      /* 若当前字符与前缀字符不同 */  
15.                 nextval[i] = j; /* 则当前的j为nextval在i位置的值 */  
16.             else   
17.             nextval[i] = nextval[j];    /* 如果与前缀字符相同，则将前缀字符的 */  
18.                             /* nextval值赋值给nextval在i位置的值 */  
19.         }   
20.     else   
21.         j= nextval[j];          /* 若字符不相同，则j值回溯 */  
22.     }  
23. }  
    
    
24. 转自：http://blog.csdn.net/u012532559/article/details/44464441