转自:http://blog.chinaunix.net/uid-26548237-id-3367953.html
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);而KMP算法,可以证明它的时间复杂度为O(m+n)。
一、简单匹配算法
先来一个简单的匹配算法的函数。
- int Index_BF(char const *S, char const *T, int pos)
- {
- /*--------------本人修改-------------*/
- if(S == NULL || T == NULL)
- {
- return -1;
- }
- if(pos < 0 || pos > strlen(S) - strlen(T))
- {
- return -1;
- }
- /*------------------------------------*/
- //若串S中从第pos(S的下标0<= pos <=StrLength(S))个字符起存在和串T相同的子串,则匹配成功。
- //返回第一个这样的子串在串S中的下标;否则返回-1
- int i = pos;
- int j = 0;
- while(S[i+j]!='\0' && T[j] != '\0')
- {
- if(S[i+j] == T[j])
- {
- j++;//继续比较后一个字符
- }
- else
- {
- //重新开始新一轮的匹配
- i++;
- j=0;
- }
- }
- if(T[j] == '\0')
- {
- return i;//匹配成功,返回下标
- }
- else
- {
- return -1;//串S中(第pos个字符起)不存在和串T相同的子串
- }
- }
例如:在串S=“abcabcabdabba”中查找T=“abcabd”(我们可以假设从下标0开始):先是比较S[0]和T[0]是否相等,然后比较S[1]和T[1]是否相等….我们发现一直比较到S[5]和T[5]才不等。如图所示。
当这样一个失配发生时,T下标必须回溯到开始,S下标回溯的长度与T相同,然后S下标增1,然后再次比较。如下图所示。
这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图所示。
这次立刻发生了失配,T下标又回溯到了开始,S下标增1,然后再次比较。如图所示。
又一次发生了失配,所以T下标又回溯到了开始,S下标增1,然后再次比较。这次T中的所有字符和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图所示。
二、KMP算法
还是相同的例子,在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。如图所示。
KMP匹配算法和简单匹配算法效率比较,一个极端的例子是:
在S=“AAAAAA…AAB”(100个A)中查找T=“AAAAAAAAAB”,简单匹配算法每次都是比较到T的结尾,发现字符不同,然后T的下标回溯到开始,S的下标也要回溯相同长度后增1,继续比较。如果使用KMP匹配算法,就不必回溯。
对于一般文稿中串的匹配,简单匹配算法的时间复杂度可降为O (m+n),因此在多数的实际应用场合下被应用。
KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子,为什么T[5] ==‘d’的模式函数值等于2(next[5]=2),起始这个2表示T[5]==‘d’的前面有两个字符和开始的两个字符相同,且T[5]==’d’不等于开始的两个字符之后的第三个字符(T[2]=‘c’)。如图所示。
也就是说,如果开始的两个字符之后的第三个字符也为‘d’,那么,尽管T[5]==‘d’的前面有2个字符和开始的两个字符相同,T[5]==’d’的模式值也不为2,而是为0.
前面我说:在S=“abcabcabdabba”中查找T=“abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5]和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根 据T中T[5]==‘d’的模式函数值,直接比较S[5] 和T[2]是否相等。为什么可以这样?
刚才我又说:“(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]是否相等。
有人可能会问: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]. 还是从理论上间接比较了。
有人疑问又来了,你分析的是不是特殊轻况啊。
假设S不变,在S中搜索T=“abaabd”呢?
答:这种情况,当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=-1,意思是S[2]已经和T[0] 间接比较过了,不相等,接下来去比较S[3]和T[0]吧。
假设S不变,在S中搜索T=“abbabd”呢?
答:这种情况当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=0,意思是S[2]已经和T[2]比较过了,不相等,接下来去比较S[2]和T[0]吧。
假设S=“abaabcabdabba”在S中搜索T=“abaabd”呢?
答:这种情况当比较到S[5]和T[5]时,发现不等,就去看next[5]的值,next[5]=2,意思是前面的比较过了,其中,S[5]的前面有两个字符和T的开始两个相等,接下来去比较S[5]和T[2]吧。
总之,有了串的next值,一切搞定。那么,怎么求串的模式函数值next[n]呢?(本文中next值、模式函数值、模式值是一个意思。)
- /*如果有什么问题,请多多指出,会虚心学习的*/
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- /*功能:求模式串值
- *参数:ptn:模式串
- *nextval:保存模式串值的数组
- */
- void get_nextval(char const *ptn, int *nextval)
- {
- int i = 0;
- nextval[0] = -1;
- int j = -1;
- int plen = strlen(ptn);
- if(ptn == NULL || nextval == NULL)
- {
- return;
- }
- while(i < plen)
- {
- if(j == -1 || ptn[i] == ptn[j])
- {
- ++i;
- ++j;
- if(ptn[i] != ptn[j])
- {
- nextval[i] = j;
- }
- else
- {
- nextval[i] = nextval[j];
- }
- }
- else
- {
- j = nextval[j];
- }
- }
- }
- /*功能:实现KMP算法
- *参数:src:源串
- * patn:模式串
- * nextval:模式串值
- * pos:源串开始的位置
- *返回值:若匹配成功,则返回下标;若出错或匹配不成功,则返回-1
- */
- int kmp_search( char const *src, char const *patn, int const *nextval,int pos)
- {
- int i = pos;
- int j = 0;
- if(src == NULL || patn ==NULL)
- {
- return -1;
- }
- int slen = strlen(src);
- int plen = strlen(patn);
- if(pos < 0 || pos > slen)
- {
- return -1;
- }
- while(i < slen && j < plen)
- {
- if(j == -1 || src[i] == patn[j])
- {
- ++i;
- ++j;
- }
- else
- {
- j = nextval[j];
- //当匹配失效时,直接用p[j_next]与s[i]比较
- //下面阐述怎么求这个值,即匹配失效后的下一次匹配的位置
- }
- }
- if( j >= plen)
- {
- return i - plen;//返回下标,从0开始
- }
- else
- {
- return -1;
- }
- }
- int main()
- {
- char src[] = "aabcabcebafabcabceabcaefabcacdabcababce";
- char prn[] = "abce";
- int *nextval = (int *)malloc(sizeof(int)* strlen(prn));
- get_nextval(prn,nextval);
- int i =0;
- for(i = 0; i < strlen(prn); i++)
- {
- printf("%d ",nextval[i]);
- }
- printf("\n");
- printf("the result is : %d\n",kmp_search(src, prn, nextval,5));
-
- return 0;
- }