KMP next nextval

先求next

1.优化过的next:他们是有规律的：

第一位的next值为0，第二位的next值为1。

       1.他们是有继承增长的规律的：如：下个元素是对称的，那么它就是前一个next元素加1  即：首先将前一位与其next值对应的内容进行比较，如果相等，则该位的next值就   是前一位的next值加上1；

       2.如果不对称那么找更小的对称，也就是在前一个对称中找子对称，即：如果不等，向前继续寻找next值对应的内容来与前一位进行比较，直到找到某个位上内容的next值对应的内容与前一位相等为止，则这个位对应的值加上1即为需求的next值；如果找到第一位都没有找到与前一位相等的内容，那么需求的位上的next值即为1。

KMP算法求next数组和nextval数组的简单方法

 

nextval 数组的求解方法是：nextval[1]=0。从第二位开始，若要求nextval[i]，将next[i]的值对应的位的值与i的值进行比较（例如，第i为的值为'b'，next[i]=3,则将i的值'b'与第三位的值进行比较），若相等，nextval[i]=nextval【next[i]】（例，nextval[i]=nextval[3]）；若不相等，则nextval[i]=next[i]（例，nextval[i]=next[i]=3 ）。

模式串	a	b	a	a	b	c	a	c
next值	0	1	1	2	2	3	1	2
nextval值	0	1	0	2	1	3	0	2

1.第一位的nextval值必定为0，第二位如果于第一位相同则为0，如果不同则为1。

  2.第三位的next值为1，那么将第三位和第一位进行比较，均为a，相同，则，第三位的nextval值为0。

3.第四位的next值为2，那么将第四位和第二位进行比较，不同，则第四位的nextval值为其next值，为2。

4.第五位的next值为2，那么将第五位和第二位进行比较，相同，第二位的next值为1，则继续将第二位与第一位进行比较，不同，则第五位的nextval值为第二位的next值，为1。

5.第六位的next值为3，那么将第六位和第三位进行比较，不同，则第六位的nextval值为其next值，为3。

6.第七位的next值为1，那么将第七位和第一位进行比较，相同，则第七位的nextval值为0。

7.第八位的next值为2，那么将第八位和第二位进行比较，不同，则第八位的nextval值为其next值，为2 。

在“aaaab”内进行验证：

模式串	a	a	a	a	b
next值	0	1	2	3	4
nextval值	0	0	0	0	4

 

next方法的实现：

（2）回头来找对称性

这里已经不能继承前面了，但是还是找对称成都嘛，最愚蠢的做法大不了写一个子函数，查找这个字符串的最大对称程度，怎么写方法很多吧，比如查找出所有的当前字符串，然后向前走，看是否一直相等，最后走到子串开头，当然这个是最蠢的，我们一般看到的KMP都是优化过的，因为这个串是有规律的。

在这里依然用上面表中一段来举个例子：   

位置i=0到14如下,我加的括号只是用来说明问题：

(a g c t a g c )( a g c t a g c) t

我们可以看到这段，最后这个t之前的对称程度分别是：1，2，3，4，5，6，7,倒数第二个c往前看有7个字符对称，所以对称为7。但是到最后这个t就没有继承前面的对称程度next值，所以这个t的对称性就要重新来求。

这里首要要申明几个事实

1、t 如果要存在对称性，那么对称程度肯定比前面这个c 的对称程度小，所以要找个更小的对称，这个不用解释了吧，如果大那么t就继承前面的对称性了。

2、要找更小的对称，必然在对称内部还存在子对称，而且这个t必须紧接着在子对称之后。

如下图说明。

 

从上面的理论我们就能得到下面的前缀next数组的求解算法。

void SetPrefix(const char *Pattern, int prefix[])

{

     int len=CharLen(Pattern);//模式字符串长度。

     prefix[0]=0;

     for(int i=1; i<len; i++)

     {

         int k=prefix[i-1];

         //不断递归判断是否存在子对称，k=0说明不再有子对称，Pattern[i] != Pattern[k]说明虽然对称，但是对称后面的值和当前的字符值不相等，所以继续递推

         while( Pattern[i] != Pattern[k]  &&  k!=0 )               

             k=prefix[k-1];     //继续递归

         if( Pattern[i] == Pattern[k])//找到了这个子对称，或者是直接继承了前面的对称性，这两种都在前面的基础上++

              prefix[i]=k+1;

         else

              prefix[i]=0;       //如果遍历了所有子对称都无效，说明这个新字符不具有对称性，清0

     }

}

 

 

 

nextval:

 

1. //修正后的求next数组各值的函数代码    
2. void get_nextval(char const* ptrn, int plen, int* nextval)    
3. {    
4.     int i = 0;  //注，此处与下文的代码实现二不同的是，i是从0开始的（代码实现二i从1开始）     
5.     nextval[i] = -1;    
6.     int j = -1;    
7.     while( i < plen-1 )    
8.     {    
9.         if( j == -1 || ptrn[i] == ptrn[j] )   //循环的if部分    
10.         {    
11.             ++i;    
12.             ++j;    
13.             //修正的地方就发生下面这4行    
14.             if( ptrn[i] != ptrn[j] ) //++i，++j之后，再次判断ptrn[i]与ptrn[j]的关系    
15.                 nextval[i] = j;      //之前的错误解法就在于整个判断只有这一句。    
16.             else    
17.                 nextval[i] = nextval[j];    
18.         }    
19.         else                                 //循环的else部分    
20.             j = nextval[j];    
21.     }    
22. } 

 

 

搜寻算法：

 

1. //代码5-1    
2. //int kmp_seach(char const*, int, char const*, int, int const*, int pos)  KMP模式匹配函数    
3. //输入：src, slen主串    
4. //输入：patn, plen模式串    
5. //输入：nextval KMP算法中的next函数值数组    
6. int kmp_search(char const* src, int slen, char const* patn, int plen, int const* nextval, int pos)    
7. {    
8.     int i = pos;    
9.     int j = 0;    
10.     while ( i < slen && j < plen )    
11.     {    
12.         if( j == -1 || src[i] == patn[j] )    
13.         {    
14.             ++i;    
15.             ++j;    
16.         }    
17.         else    
18.         {    
19.             j = nextval[j];              
20.             //当匹配失败的时候直接用p[j_next]与s[i]比较，    
21.             //下面阐述怎么求这个值，即匹配失效后下一次匹配的位置    
22.         }    
23.     }    
24.     if( j >= plen )    
25.         return i-plen;    
26.     else    
27.         return -1;    
28. }