字符串模式匹配KMP算法

[align=left]一篇不错的博客：/article/4719933.html[/align]
[align=left]KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。[/align]
[align=left]一.简单匹配算法[/align]
[align=left]先来看一个简单匹配算法的函数：[/align]
[align=left]int Index_BF ( char S [ ], char T [ ], int pos )[/align]
[align=left]{[/align]
[align=left]/* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符[/align]
[align=left]起存在和串 T 相同的子串，则称匹配成功，返回第一个[/align]
[align=left]这样的子串在串 S 中的下标，否则返回 -1 */[/align]
[align=left]int i = pos, j = 0;[/align]
[align=left]while ( S[i+j] != '/0'&& T[j] != '/0')[/align]
[align=left]if ( S[i+j] == T[j] )[/align]
[align=left]j ++; // 继续比较后一字符[/align]
[align=left]else[/align]
[align=left]{[/align]
[align=left]i ++; j = 0; // 重新开始新的一轮匹配[/align]
[align=left]}[/align]
[align=left]if ( T[j] == '/0')[/align]
[align=left]return i; // 匹配成功 返回下标[/align]
[align=left]else[/align]
[align=left]return -1; // 串S中(第pos个字符起)不存在和串T相同的子串[/align]
[align=left]} // Index_BF
此算法的思想是直截了当的：将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较S[i+j] 与 T[j]，若相等，则在主串 S 中存在以 i 为起始位置匹配成功的可能性，继续往后比较( j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即 i 增1，而 j 退回至0，重新开始新一轮的匹配。[/align]
[align=left]例如：在串S=”abcabcabdabba”中查找T=” abcabd”（我们可以假设从下标0开始）:先是比较S[0]和T[0]是否相等，然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图：[/align]



[align=left] [/align]
[align=left]当这样一个失配发生时，T下标必须回溯到开始，S下标回溯的长度与T相同，然后S下标增1,然后再次比较。如图：[/align]
[align=left]这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图：[/align]



[align=left]这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图：[/align]



又一次发生了失配，所以T下标又回溯到开始，S下标增1,然后再次比较。这次T中的所有字符都和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图：



[align=left]二. KMP匹配算法[/align]
[align=left]还是相同的例子，在S=”abcabcabdabba”中查找T=”abcabd”，如果使用KMP匹配算法，当第一次搜索到S[5] 和T[5]不等后，S下标不是回溯到1，T下标也不是回溯到开始，而是根据T中T[5]==’d’的模式函数值（next[5]=2，为什么？后面讲），直接比较S[5] 和T[2]是否相等，因为相等，S和T的下标同时增加;因为又相等，S和T的下标又同时增加。。。最终在S中找到了T。如图：[/align]



[align=left]KMP匹配算法和简单匹配算法效率比较，一个极端的例子是：[/align]
[align=left]在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾，发现字符不同，然后T的下标回溯到开始，S的下标也要回溯相同长度后增1，继续比较。如果使用KMP匹配算法，就不必回溯.[/align]
[align=left]对于一般文稿中串的匹配，简单匹配算法的时间复杂度可降为O (m+n)，因此在多数的实际应用场合下被应用。[/align]
[align=left]KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子。为什么T[5]==’d’的模式函数值等于2（next[5]=2），其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同，且T[5]==’d’不等于开始的两个字符之后的第三个字符（T[2]=’c’）.如图：[/align]



[align=left]也就是说，如果开始的两个字符之后的第三个字符也为’d’,那么，尽管T[5]==’d’的前面有2个字符和开始的两个字符相同，T[5]==’d’的模式函数值也不为2，而是为0。[/align]
[align=left] 前面我说：在S=”abcabcabdabba”中查找T=”abcabd”，如果使用KMP匹配算法，当第一次搜索到S[5] 和T[5]不等后，S下标不是回溯到1，T下标也不是回溯到开始，而是根据T中T[5]==’d’的模式函数值，直接比较S[5] 和T[2]是否相等。。。为什么可以这样？[/align]
[align=left]刚才我又说：“（next[5]=2），其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同”。请看图 ：因为，S[4] ==T[4]，S[3] ==T[3]，根据next[5]=2，有T[3]==T[0]，T[4] ==T[1]，所以S[3]==T[0]，S[4] ==T[1]（两对相当于间接比较过了），因此，接下来比较S[5] 和T[2]是否相等。。。[/align]



[align=left]有人可能会问：S[3]和T[0]，S[4] 和T[1]是根据next[5]=2间接比较相等，那S[1]和T[0]，S[2] 和T[0]之间又是怎么跳过，可以不比较呢？因为S[0]=T[0]，S[1]=T[1]，S[2]=T[2]，而T[0] != T[1], T[1] != T[2],==> S[0] != S[1],S[1] != S[2],所以S[1] != T[0],S[2] != T[0]. 还是从理论上间接比较了。[/align]
[align=left]有人疑问又来了，你分析的是不是特殊轻况啊。[/align]
[align=left]假设S不变，在S中搜索T=“abaabd”呢？答：这种情况，当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]=-1，意思是S[2]已经和T[0] 间接比较过了，不相等，接下来去比较S[3]和T[0]吧。[/align]
[align=left]假设S不变，在S中搜索T=“abbabd”呢？答：这种情况当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]=0，意思是S[2]已经和T[2]比较过了，不相等，接下来去比较S[2]和T[0]吧。[/align]
[align=left]假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢？答：这种情况当比较到S[5]和T[5]时，发现不等，就去看next[5]的值，next[5]=2，意思是前面的比较过了，其中，S[5]的前面有两个字符和T的开始两个相等，接下来去比较S[5]和T[2]吧。[/align]
总之，有了串的next值，一切搞定。那么，怎么求串的模式函数值next
呢？（本文中next值、模式函数值、模式值是一个意思。）
三. 怎么求串的模式值next

[align=left]定义：比较重要的地方 按一下规则匹配[/align]
[align=left]（1）next[0]= -1 意义：任何串的第一个字符的模式值规定为-1。[/align]

[align=left]（2）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （1≤k<j）。[/align]
[align=left] 即T[0]T[1]T[2]。。。T[k-1]==T[j-k]T[j-k+1]T[j-k+2]…T[j-1]且T[j] != T[k].（1≤k<j）;[/align]
[align=left] [/align]

[align=left]（3）next[j]= -1 意义：模式串T中下标为j的字符，如果与T[0]相同，且j的前面的1—k个字符与开头的1—k[/align]
[align=left]个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6][/align]
[align=left] (4) next[j]=0 意义：除（1）（2）（3）的其他情况。[/align]

四. 求串T的模式值next
的函数
说了这么多，是不是觉得求串T的模式值next
很复杂呢？要叫我写个函数出来，目前来说，我宁愿去登天。好在有现成的函数，当初发明KMP算法，写出这个函数的先辈，令我佩服得六体投地。我等后生小子，理解起来，都要反复琢磨。下面是这个函数:
[align=left]void get_nextval(const char *T, int next[])[/align]
[align=left]{[/align]
[align=left] // 求模式串T的next函数值并存入数组 next。[/align]
[align=left] int j = 0, k = -1;[/align]
[align=left] next[0] = -1;[/align]
[align=left] while ( T[j/*+1*/] != '/0' )[/align]
[align=left] {[/align]
[align=left] if (k == -1 || T[j] == T[k])[/align]
[align=left] {[/align]
[align=left] ++j; ++k;[/align]
[align=left] if (T[j]!=T[k])[/align]
[align=left] next[j] = k;[/align]
[align=left] else[/align]
[align=left] next[j] = next[k];[/align]
[align=left] }// if[/align]
[align=left] else[/align]
[align=left] k = next[k];[/align]
[align=left] }// while[/align]
[align=left] ////这里是我加的显示部分[/align]
[align=left] // for(int i=0;i<j;i++)[/align]
[align=left] //{[/align]
[align=left] // cout<<next[i];[/align]
[align=left] //}[/align]
[align=left] //cout<<endl;[/align]
[align=left]}// get_nextval　[/align]
[align=left]另一种写法，也差不多。[/align]
[align=left]void getNext(const char* pattern,int next[])[/align]
[align=left]{[/align]
[align=left] next[0]= -1;[/align]
[align=left] int k=-1,j=0;[/align]
[align=left] while(pattern[j] != '/0')[/align]
[align=left] {[/align]
[align=left] if(k!= -1 && pattern[k]!= pattern[j] )[/align]
[align=left] k=next[k];[/align]
[align=left] ++j;++k;[/align]
[align=left] if(pattern[k]== pattern[j])[/align]
[align=left] next[j]=next[k];[/align]
[align=left] else[/align]
[align=left] next[j]=k;[/align]
[align=left] }[/align]
[align=left] ////这里是我加的显示部分[/align]
[align=left] // for(int i=0;i<j;i++)[/align]
[align=left] //{[/align]
[align=left] // cout<<next[i];[/align]
[align=left] //}[/align]
[align=left] //cout<<endl;[/align]
[align=left]}[/align]
[align=left]下面是KMP模式匹配程序，各位可以用他验证。记得加入上面的函数[/align]
[align=left]#include <iostream.h>[/align]
[align=left]#include <string.h>[/align]
[align=left]int KMP(const char *Text,const char* Pattern) //const 表示函数内部不会改变这个参数的值。[/align]
[align=left]{[/align]
[align=left] if( !Text||!Pattern|| Pattern[0]=='/0' || Text[0]=='/0' )//[/align]
[align=left] return -1;//空指针或空串，返回-1。[/align]
[align=left] int len=0;[/align]
[align=left] const char * c=Pattern;[/align]
[align=left] while(*c++!='/0')//移动指针比移动下标快。[/align]
[align=left] { [/align]
[align=left] ++len;//字符串长度。[/align]
[align=left] }[/align]
[align=left] int *next=new int[len+1];[/align]
[align=left] get_nextval(Pattern,next);//求Pattern的next函数值[/align]
[align=left] [/align]
[align=left] int index=0,i=0,j=0;[/align]
[align=left] while(Text[i]!='/0' && Pattern[j]!='/0' )[/align]
[align=left] {[/align]
[align=left] if(Text[i]== Pattern[j])[/align]
[align=left] {[/align]
[align=left] ++i;// 继续比较后继字符[/align]
[align=left] ++j;[/align]
[align=left] }[/align]
[align=left] else[/align]
[align=left] {[/align]
[align=left] index += j-next[j];[/align]
[align=left] if(next[j]!=-1)[/align]
[align=left] j=next[j];// 模式串向右移动[/align]
[align=left] else[/align]
[align=left] {[/align]
[align=left] j=0;[/align]
[align=left] ++i;[/align]
[align=left] }[/align]
[align=left] }[/align]
[align=left] }//while[/align]
[align=left] [/align]
[align=left] delete []next;[/align]
[align=left] if(Pattern[j]=='/0')[/align]
[align=left] return index;// 匹配成功[/align]
[align=left] else[/align]
[align=left] return -1; [/align]
[align=left]}[/align]
[align=left]int main()//abCabCad[/align]
[align=left]{[/align]
[align=left] char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc";[/align]
[align=left] char*pattern="adCadCad";[/align]
[align=left] //getNext(pattern,n);[/align]
[align=left] //get_nextval(pattern,n);[/align]
[align=left] cout<<KMP(text,pattern)<<endl;[/align]
[align=left] return 0;[/align]
[align=left]}[/align]
[align=left]参考博客：/article/1778695.html[/align]
[align=left] [/align]
[align=left]补充一段写的不错的：[/align]

KMP算法的实现

KMP算法的是对匹配的模式匹配算法的改进，在s[i]和p[j]匹配不成功时，不是对主串进行指针的回溯，而是在p[1,…,j-1]中，寻找一个p[k],

用s[i]和p[k]进行下一轮的匹配。其实现的最大问题就是如何的根据p[1,…,j-1]来求出p[k]。

在KMP算法的实现中，使用一个辅助数组next[],使用该数组保存p[j]匹配不成功时，要进行下一轮匹配的k的值.即是当s[i] 和 p[j]匹配不成功时，

用p[ next[j] ]来和s[i]进行下一轮匹配，k = next[j] .

对数组next[] 的求解，可以goolge到不少的方法，这里使用最简单的递推的方法：

首先假定next[0] = –1,那么当next[j] = k时，就有：p[0,…,j-1] == p[j-k+1,…,j-1]。

这时，若有p[k] = p[j] ，则p[0,….,k] = p[j-k+1,..,j-1,j]，从而就有next[j+1] = next[j] + 1 = k +1 .

若p[k] != p[j] ,可以看着模式串对自身进行匹配的问题，即当匹配失败的时候，k值如何确定，k = next [k] .

求数组next[ ]的实现如下：

/*
KMP进行模式匹配的辅助函数
模式串和主串匹配不成功时，下次和主串进行匹配的模式串的位置
*/
void continue_prefix_function(const char * p , int * next) {
int j ;
int k ;
next[0] = -1 ;
j = 0 ;
k = -1 ;

while(j < strlen(p) - 1) {
if( k == -1 || p[k] == p[j]) {
j ++ ;
k ++ ;
next[j] = k ;
}else {
k =next[k] ;
}
}
}

知道了当模式串和主串匹配不成功时，下一个和主串匹配的字符在模式串中的位置，在朴素的模式匹配的基础上很容易的写出KMP算法的代码如下：

/*
运用KMP算法的字符串模式匹配
在主串和模式串匹配不成功时，不对主串指针进行回溯，
例如用next[j],来指定下一次和主串进行匹配的模式串的位置
*/
int match_kmp(const char * s ,const char * p,int pos) {
int next[11] ;
int i = pos ;
int j = 0 ;
continue_prefix_function(p,next) ;
while(s[i] != '\0' && p[j] != '\0') {
if(s[i] == p[j]) {
i ++ ;
j ++ ;
}else {
if(next[j] == -1) {
i ++ ;
j = 0 ;
}
else {
j = next[j] ;
}
}
}
if(p[j] == '\0')
return i - j ;
else
return -1 ;
}

参考博文:/article/5704298.html