KMP算法【转】

 

以下是转载内容：

☆─────────────────────────传说中的分隔符───────────────────────────────────────☆

来源1：http://www.programfan.com/blog/article.asp?id=15762    

模式匹配的KMP算法详解

这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KMP算法。大概学过信息学的都知道，是个比较难理解的算法，今天特把它搞个彻彻底底明明白白。

注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法：

 

1. int Index(String S,String T,int pos)//参考《数据结构》中的程序  
2. {  
3.          i=pos;j=1;//这里的串的第1个元素下标是1  
4.          while(i<=S.Length && j<=T.Length)  
5.          {  
6.                    if(S[i]==T[j]){++i;++j;}  
7.                    else{i=i-j+2;j=1;}//**************(1)  
8.          }  
9.          if(j>T.Length) return i-T.Length;//匹配成功  
10.           else return 0;  
11. }  

  

 

匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？回溯，没错，注意到(1)句，为什么要回溯，看下面的例子：

S:aaaaabababcaaa  T:ababc

aaaaabababcaaa

ababc.(.表示前一个已经失配)

回溯的结果就是

aaaaabababcaaa

     a.(babc)
如果不回溯就是

aaaaabababcaaa

        aba.bc

这样就漏了一个可能匹配成功的情况

aaaaabababcaaa

      ababc

为什么会发生这样的情况？这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为abcdef这样的，大没有回溯的必要。

改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。

如果不用回溯，那T串下一个位置从哪里开始呢？

还是上面那个例子，T为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样：

...ababd...

   ababc

   ->ababc

这样i不用回溯，j跳到前2个位置，继续匹配的过程，这就是KMP算法所在。这个当T[j]失配后，j应该往前跳的值就是j的next值，它是由T串本身固有决定的，与S串无关。

《数据结构》上给了next值的定义：

next[j]=0如果j=1

next[j]={Max{k|1<k<j且'p1...pk-1'='pj-k+1...pj-1'

next[j]=1   其它情况

我当初看到这个头就晕了，其实它就是描述的我前面表述的情况，关于next[1]=0是规定的，这样规定可以使程序简单一些，如果非要定为其它的值只要不和后面的值冲突也是可以的；而那个Max是什么意思，举个例子：

T:aaab

...aaaab...

   aaab

  ->aaab

   ->aaab

->aaab

像这样的T，前面自身部分匹配的部分不止两个，那应该往前跳到第几个呢？最近的一个，也就是说尽可能的向右滑移最短的长度。

OK，了解到这里，就看清了KMP的大部分内容，然后关键的问题是如何求next值？先不管它，先看如何用它来进行匹配操作，也就是说先假设已经有了next值。

将最前面的程序改写成：

1. int Index_KMP(String S,String T,int pos)  
2. {  
3.   i=pos;j=1;//这里的串的第1个元素下标是1  
4.   while(i<=S.Length && j<=T.Length)  
5.   {  
6.     if(j==0 || S[i]==T[j]){++i;++j;} //注意到这里的j==0,和++j的作用就知道为什么规定next[1]=0的好处了  
7.     else j=next[j];//i不变（不回溯）,j跳动  
8.   }  
9.   if(j>T.Length) return i-T.Length;//匹配成功  
10.   else return 0;  
11. }  

OK,是不是非常简单？还有更简单的，求next值，这也是整个算法成功的关键，从next值的定义来求太恐怖了，怎么求？前面说过了，next值表达的就是T串的自身部分匹配的性质，那么，我只要将T串和T串自身来一次匹配就可以求出来了，这里的匹配过程不是从头一个一个匹配，而是从T[1]和T[2]开始匹配，给出算法如下：

1. int Index_KMP(String S,String T,int pos)  
2. {  
3.     i=pos;j=1;//这里的串的第1个元素下标是1  
4.     while(i<=S.Length && j<=T.Length)  
5.     {  
6.     if(j==0 || S[i]==T[j]){++i;++j;} //注意到这里的j==0,和++j的作用就知道为什么规定next[1]=0的好处了  
7.     else j=next[j];//i不变（不回溯）,j跳动  
8.     }  
9.     if(j>T.Length) return i-T.Length;//匹配成功  
10.     else return 0;  
11. }  

看这个函数是不是非常像KMP匹配的函数，没错，它就是这么干的！注意到(2)语句逻辑覆盖的时候是T[i]==T[j]以及i前面的、j前面的都匹配的情况下，于是先自增，然后记下来next[i]=j，这样每当i有自增就会求得一个next[i]，而j一定会小于等于i，于是对于已经求出来的next，可以继续求后面的next，而next[1]=0是已知，所以整个就这样递推的求出来了，方法非常巧妙。

这样的改进已经是很不错了，但算法还可以改进，注意到下面的匹配情况：

...aaac...

   aaaa.

T串中的'a'和S串中的'c'失配，而'a'的next值指的还是'a'，那同样的比较还是会失配，而这样的比较是多余的，如果我事先知道，当T[i]==T[j]，那next[i]就设为next[j]，在求next值的时候就已经比较了，这样就可以去掉这样的多余的比较。于是稍加改进得到：

1. void get_nextval(String T,int &next[])  
2. {  
3.     i=1;j=0;next[1]=0;  
4.     while(i<=T.Length)  
5.     {  
6.         if(j==0 || T[i]==T[j])  
7.         {   
8.             ++i;  
9.             ++j;  
10.             if(T[i]!=T[j]) next[i]=j;  
11.             else next[i]=next[j];//消去多余的可能的比较,next再向前跳  
12.         }  
13.         else j=next[j];  
14.     }  
15. }  

匹配算法不变。

到此就完全弄清楚了，以前老觉得KMP算法好神秘，真不是人想出来的，其实不然，它只不过是对原有的算法进行了改进。可见基础的经典的东西还是很重要，你有本事‘废’了经典，就创造了进步。

 

 

☆─────────────────────────传说中的分隔符───────────────────────────────────────☆

来源2：http://blog.chinaunix.net/u2/76292/showart_1661980.html  

kmp算法

设有主串s和子串t，子串t定位是指在主串s中找到一个与子串t相等的子串。通常把主串s称为目标串，把子串t称为模式串，因此定位也称作模式匹配。模式匹配成功是指在目标串s中找到一个模式串t。

传统的字符串模式匹配算法（也就是BF算法）就是对于主串和模式串双双自左向右，一个一个字符比较，如果不匹配，主串和模式串的位置指针都要回溯。这样的算法时间复杂度为O（n＊m），其中n和m分别为串s和串t的长度。

KMP 算法是由Knuth，Morris和Pratt等人共同提出的，所以成为Knuth－Morris－Pratt算法，简称KMP算法。KMP算法是字符串模式匹配中的经典算法。和BF算法相比，KMP算法的不同点是匹配过程中，主串的位置指针不会回溯，这样的结果使得算法时间复杂度只为O（n＋m）。下面说说KMP算法的原理。

假设我们有个模式串为“abdabcde”存于数组t，我们要求的就是模式串的next值，见下表所示：

 

i	0	1	2	3	4	5	6	7
t[i]	a	b	d	a	b	c	d	e
next[i]	-1	0	0	0	1	2	0	0

求模式t的next[i]（称为失效函数）的公式如下：

 

next[i]= 

 

 

( 上面的公式中非t字母和数字组成的为数组下标)

应该如何理解next数组呢？在匹配过程中，如果出现不匹配的情况（当前模式串不匹配字符假定为t[i]），它所对应的next[i]的数值为接下来要匹配的模式串的字符的索引；也就是说，出现不匹配的情况时，模式串的索引指针要回溯到中next[i]所对应的位置，而主串的索引指针保持不变。

特别的，next数组中的next[0]和next[1]的取值是固定的，为了标识出首字母，需要假定next[0]为－1（取为－1是考虑到C语言中的数组索引以0开始）。在实现的时候，要实现公式中情况的处理需要些技巧，下面给出具体的实现：

1. #include <stdio.h>  
2. #include <stdlib.h>   
3.   
4. typedef struct QString{  
5.     char *  cs;  
6.     int  len;  
7. }String;  
8.   
9. void GetNext(String s, int next [])  
10. {  
11.     int len  =  s.len;  
12.     int i = 0 ;  
13.     int k = - 1 ;  
14.     next[0] = - 1 ;  
15.     while (i < len - 1 ){  
16.         if (k ==- 1 || s.cs[i] == s.cs[k]){  
17.             i ++ ;  
18.             k ++ ;  
19.             next[i] = k;  
20.         }else{  
21.             k = next[k];  
22.         }  
23.     }  
24. }  
25.   
26.   
27. int KMPIndex(String s, String m)  
28. {  
29.     int next[m.len], i = 0, j = 0 ;  
30.     int k;  
31.     GetNext(m, next);  
32.     while (i < s.len && j < m.len){  
33.         if (j == - 1 || s.cs[i] == m.cs[j]){  
34.             i ++ ;  
35.             j ++ ;  
36.         }else{  
37.             j = next[j];  
38.         }  
39.     }  
40.     if(j >= m.len) return i - m.len;  
41.     else   return -1 ;  
42. }  

KMP 算法也有需要改进的地方。对于模式串“aaaadd”在匹配时（假定被匹配串为“aaadddd”），可以看到，在匹配到索引3时，主串字符为“d”，模式串字符为“a”，如果按照上面的做法，这时模式串只会回溯一个索引，由于仍不匹配，模式串还会回溯一个索引，直到索引位置到了首字符，主串的索引指针才会前进一位，这样就会浪费一些不必要的比较时间。出现这种情况的原因是模式串中位置i的字符与next[i]对应的字符相同，需要修正next[i]为next[i]对应的字符的索引。下面列出“aaaadd”修正的nextval数组的内容：

i	0	1	2	3	4	5
t[i]	a	a	a	a	d	d
next[i]	-1	0	1	2	3	0
nextval[i]	-1	-1	-1	-1	0	0

修正函数如下：

1. void GetNextval(String s, int nextval[])  
2. {  
3.     int len = s.len, i = 0, k = -1 ;  
4.     nextval[0] = -1 ;  
5.     while (i  < len - 1){  
6.         if (k == - 1 || s.cs[i] == s.cs[k]){  
7.             i ++ ;  
8.             k ++ ;  
9.             if (s.cs[i] != s.cs[k]){  
10.                 nextval[i] = k;  
11.             }else  
12.                 nextval[i] = nextval[k];              
13.         }else{  
14.             k = nextval[k];  
15.         }  
16.     }  
17. }