KMP字符串模式匹配详解
2013-06-12 17:16
330 查看
来自CSDN A_B_C_ABC 网友
KMP字符串模式匹配详解
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。
一.简单匹配算法
先来看一个简单匹配算法的函数：
int Index_BF ( char S [ ], char T [ ], int pos )
{
/* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符
起存在和串 T 相同的子串，则称匹配成功，返回第一个
这样的子串在串 S 中的下标，否则返回 -1 */
int i = pos, 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相同的子串
} // Index_BF
此算法的思想是直截了当的：将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较S[i+j] 与 T[j]，若相等，则在主串 S 中存在以 i 为起始位置匹配成功的可能性，继续往后比较(
j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即 i 增1，而 j 退回至0，重新开始新一轮的匹配。
例如：在串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’的前面有2个字符和开始的两个字符相同，且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
呢？（本文中next值、模式函数值、模式值是一个意思。）
三. 怎么求串的模式值next
定义：
（1）next[0]=
-1 意义：任何串的第一个字符的模式值规定为-1。
（2）next[j]=
-1 意义：模式串T中下标为j的字符，如果与首字符相同(T[j]
== T[0])，且j的前面的1—k个字符与开头的1—k
个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。
如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]
这里分两种情况：1.前k个字符不等；2.前k个字符相等&&T[k]==T[j]
前提都是T[j]
== T[0]
（3）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个
字符与开头的k个字符相等，且T[j]
!= T[k] （1≤k<j）。
即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）;
（4） next[j]=0 意义：除（1）（2）（3）的其他情况。
[align=left]看完有点晕，总结一下：[/align]
[align=left]先看T[j]是否等于T[0]，如果不等，则按第（3）点来判断；[/align]
[align=left]如果相等，则可能是（2）也可能是（3），先判断前k个字符是否相等；若不等，则为（2）前半部分；若相等，若再看T[j]与T[k]是否相等，相等则为（2）后半部分，不相等则为（3）。[/align]
[align=left]这里（2）（3）判断的前提都是（1 <= k < j ），在判断前2、3位时比较有用。[/align]
举例：
01）求T=“abcac”的模式函数的值。
next[0]= -1 根据（1）
next[1]=0 根据 (4) 因（3）有1<=k<j;不能说，j=1,T[j-1]==T[0]
next[2]=0 根据 (4) 因（3）有1<=k<j;（T[0]=a）!=（T[1]=b）
next[3]= -1 根据 (2)
next[4]=1 根据 (3) T[0]=T[3] 且 T[1]=T[4]
即
若T=“abcab”将是这样：
为什么T[0]==T[3],还会有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j]
!= T[k]”被划入（4）。
02）来个复杂点的，求T=”ababcaabc” 的模式函数的值。
next[0]= -1 根据（1）
next[1]=0 根据(4)
next[2]=-1 根据 (2)
next[3]=0 根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入（4）
next[4]=2 根据 (3) T[0]T[1]=T[2]T[3] 且T[2]
!=T[4]
next[5]=-1 根据 (2)
next[6]=1 根据 (3) T[0]=T[5] 且T[1]!=T[6]
next[7]=0 根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入（4）
next[8]=2 根据 (3) T[0]T[1]=T[6]T[7] 且T[2]
!=T[8]
即
只要理解了next[3]=0，而不是=1，next[6]=1，而不是=
-1，next[8]=2，而不是= 0，其他的好象都容易理解。
03) 来个特殊的，求 T=”abCabCad” 的模式函数的值。
next[5]= 0 根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5]
next[6]= -1 根据 (2) 虽前面有abC=abC,但T[3]==T[6]
next[7]=4 根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]
若T[4]==T[7]，即T=” adCadCad”,那么将是这样：next[7]=0, 而不是=
4,因为T[4]==T[7].
如果你觉得有点懂了，那么
练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。
结果：-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 9
为什么是9不是10？（1 <= k < j ）
意义：
next 函数值究竟是什么含义，前面说过一些，这里总结。
设在字符串S中查找模式串T，若S[m]!=T
,那么，取T
的模式函数值next
,
1. next
= -1
表示S[m]和T[0]间接比较过了，不相等，下一次比较 S[m+1] 和T[0]
2. next
=0
表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]
3. next
=
k >0 & k<n
表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]
4. 其他值，不可能。
四. 求串T的模式值next
的函数
说了这么多，是不是觉得求串T的模式值next
很复杂呢？要叫我写个函数出来，目前来说，我宁愿去登天。好在有现成的函数，当初发明KMP算法，写出这个函数的先辈，令我佩服得六体投地。我等后生小子，理解起来，都要反复琢磨。下面是这个函数:
下面是KMP模式匹配程序，各位可以用他验证。记得加入上面的函数
KMP字符串模式匹配详解
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。
一.简单匹配算法
先来看一个简单匹配算法的函数：
int Index_BF ( char S [ ], char T [ ], int pos )
{
/* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符
起存在和串 T 相同的子串，则称匹配成功，返回第一个
这样的子串在串 S 中的下标，否则返回 -1 */
int i = pos, 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相同的子串
} // Index_BF
此算法的思想是直截了当的：将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较S[i+j] 与 T[j]，若相等，则在主串 S 中存在以 i 为起始位置匹配成功的可能性，继续往后比较(
j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即 i 增1，而 j 退回至0，重新开始新一轮的匹配。
例如：在串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’的前面有2个字符和开始的两个字符相同，且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
呢？（本文中next值、模式函数值、模式值是一个意思。）
三. 怎么求串的模式值next
定义：
（1）next[0]=
-1 意义：任何串的第一个字符的模式值规定为-1。
（2）next[j]=
-1 意义：模式串T中下标为j的字符，如果与首字符相同(T[j]
== T[0])，且j的前面的1—k个字符与开头的1—k
个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。
如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]
这里分两种情况：1.前k个字符不等；2.前k个字符相等&&T[k]==T[j]
前提都是T[j]
== T[0]
（3）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个
字符与开头的k个字符相等，且T[j]
!= T[k] （1≤k<j）。
即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）;
（4） next[j]=0 意义：除（1）（2）（3）的其他情况。
[align=left]看完有点晕，总结一下：[/align]
[align=left]先看T[j]是否等于T[0]，如果不等，则按第（3）点来判断；[/align]
[align=left]如果相等，则可能是（2）也可能是（3），先判断前k个字符是否相等；若不等，则为（2）前半部分；若相等，若再看T[j]与T[k]是否相等，相等则为（2）后半部分，不相等则为（3）。[/align]
[align=left]这里（2）（3）判断的前提都是（1 <= k < j ），在判断前2、3位时比较有用。[/align]
举例：
01）求T=“abcac”的模式函数的值。
next[0]= -1 根据（1）
next[1]=0 根据 (4) 因（3）有1<=k<j;不能说，j=1,T[j-1]==T[0]
next[2]=0 根据 (4) 因（3）有1<=k<j;（T[0]=a）!=（T[1]=b）
next[3]= -1 根据 (2)
next[4]=1 根据 (3) T[0]=T[3] 且 T[1]=T[4]
即
| [align=left]下标[/align] | [align=left]0[/align] | [align=left]1[/align] | [align=left]2[/align] | [align=left]3[/align] | [align=left]4[/align] |
| [align=left]T[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]c[/align] | [align=left]a[/align] | [align=left]c[/align] |
| [align=left]next[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]1[/align] |
| [align=left]下标[/align] | [align=left]0[/align] | [align=left]1[/align] | [align=left]2[/align] | [align=left]3[/align] | [align=left]4[/align] |
| [align=left]T[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]c[/align] | [align=left]a[/align] | [align=left]b[/align] |
| [align=left]next[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]0[/align] |
!= T[k]”被划入（4）。
02）来个复杂点的，求T=”ababcaabc” 的模式函数的值。
next[0]= -1 根据（1）
next[1]=0 根据(4)
next[2]=-1 根据 (2)
next[3]=0 根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入（4）
next[4]=2 根据 (3) T[0]T[1]=T[2]T[3] 且T[2]
!=T[4]
next[5]=-1 根据 (2)
next[6]=1 根据 (3) T[0]=T[5] 且T[1]!=T[6]
next[7]=0 根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入（4）
next[8]=2 根据 (3) T[0]T[1]=T[6]T[7] 且T[2]
!=T[8]
即
| [align=left]下标[/align] | [align=left]0[/align] | [align=left]1[/align] | [align=left]2[/align] | [align=left]3[/align] | [align=left]4[/align] | [align=left]5[/align] | [align=left]6[/align] | [align=left]7[/align] | [align=left]8[/align] |
| [align=left]T[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]c[/align] | [align=left]a[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]c[/align] |
| [align=left]next[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]2[/align] | [align=left]-1[/align] | [align=left]1[/align] | [align=left]0[/align] | [align=left]2[/align] |
-1，next[8]=2，而不是= 0，其他的好象都容易理解。
03) 来个特殊的，求 T=”abCabCad” 的模式函数的值。
| [align=left]下标[/align] | [align=left]0[/align] | [align=left]1[/align] | [align=left]2[/align] | [align=left]3[/align] | [align=left]4[/align] | [align=left]5[/align] | [align=left]6[/align] | [align=left]7[/align] |
| [align=left]T[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]C[/align] | [align=left]a[/align] | [align=left]b[/align] | [align=left]C[/align] | [align=left]a[/align] | [align=left]d[/align] |
| [align=left]next[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]4[/align] |
next[5]= 0 根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5]
next[6]= -1 根据 (2) 虽前面有abC=abC,但T[3]==T[6]
next[7]=4 根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]
若T[4]==T[7]，即T=” adCadCad”,那么将是这样：next[7]=0, 而不是=
4,因为T[4]==T[7].
| [align=left]下标[/align] | [align=left]0[/align] | [align=left]1[/align] | [align=left]2[/align] | [align=left]3[/align] | [align=left]4[/align] | [align=left]5[/align] | [align=left]6[/align] | [align=left]7[/align] |
| [align=left]T[/align] | [align=left]a[/align] | [align=left]d[/align] | [align=left]C[/align] | [align=left]a[/align] | [align=left]d[/align] | [align=left]C[/align] | [align=left]a[/align] | [align=left]d[/align] |
| [align=left]next[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]0[/align] | [align=left]0[/align] | [align=left]-1[/align] | [align=left]0[/align] |
如果你觉得有点懂了，那么
练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。
结果：-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 9
为什么是9不是10？（1 <= k < j ）
意义：
next 函数值究竟是什么含义，前面说过一些，这里总结。
设在字符串S中查找模式串T，若S[m]!=T
,那么，取T
的模式函数值next
,
1. next
= -1
表示S[m]和T[0]间接比较过了，不相等，下一次比较 S[m+1] 和T[0]
2. next
=0
表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]
3. next
=
k >0 & k<n
表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]
4. 其他值，不可能。
四. 求串T的模式值next
的函数
说了这么多，是不是觉得求串T的模式值next
很复杂呢？要叫我写个函数出来，目前来说，我宁愿去登天。好在有现成的函数，当初发明KMP算法，写出这个函数的先辈，令我佩服得六体投地。我等后生小子，理解起来，都要反复琢磨。下面是这个函数:
void get_nextval(const char *T, int next[])
{
int j = 0, k = -1;
next[0] = -1;
while ( T[j] != '\0' )
{
if (k == -1 || T[j] == T[k])
{
++j; ++k;
if (T[j]!=T[k])
next[j] = k;
else
next[j] = next[k];
}
else
k = next[k];
}
}下面是KMP模式匹配程序，各位可以用他验证。记得加入上面的函数
int Index_KMP(const char *Text, const char *Pattern) //const 表示函数内部不会改变这个参数的值。
{
if (!Text || !Pattern || Pattern[0] == '\0' || Text[0] == '\0')
return -1;//空指针或空串，返回-1
//取Pattern长度
int len=0;
const char *p=Pattern;
while (*p++ != '\0')//移动指针比移动下标快
{
++len;//字符串长度
}
//求Pattern的next函数值
int *next = new int[len + 1];
get_nextval(Pattern, next);
//匹配，返回index
int index = 0, i = 0, j = 0;
while (Text[i] != '\0' && Pattern[j] != '\0')
{
if (Text[i] == Pattern[j])
{
++i;// 继续比较后继字符
++j;
}
else
{
index += j-next[j];
if (next[j] != -1)
j=next[j];// 模式串向右移动
else
{
j=0;
++i;
}
}//else
}//while
delete []next;
if (Pattern[j] == '\0')
return index; // 匹配成功
else
return -1;
}
int main()
{
char *text = "abcabcabdabba";
char *pattern = "abcabd";
cout << Index_KMP(text, pattern) << endl;
return 0;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 