KMP字符串模式匹配详解

http://www.cppblog.com/oosky/archive/2006/07/06/9486.html

KMP字符串模式匹配详解

来自CSDN A_B_C_ABC 网友

KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);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;
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中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较 S[i+j] 与 T[j]，若相等，则在主串S 中存在以 i 为起始位置匹配成功的可能性，继续往后比较( j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即 i 增1，而 j 退回至0，重新开始新一轮的匹配。

　　对于一般文稿中串的匹配，简单匹配算法的时间复杂度可降为O (m+n)，因此在多数的实际应用场合下被应用。

二. KMP匹配算法 时间复杂度为O(m+n)

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



　　KMP匹配算法和简单匹配算法效率比较，一个极端的例子是：在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾，发现字符不同，然后T的下标回溯到开始，S的下标也要回溯相同长度后增1，继续比较。如果使用KMP匹配算法，就不必回溯.　　

　　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=”abcabcabdabba”)

　　假设S不变，在S中搜索T=“abaabd”呢？答：这种情况，当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]= -1，意思是S[2]已经和T[0] 间接比较过了，不相等，接下来去比较S[3]和T[0]吧。(a与首字符相同，且满足条件（2）中的（a），所以为-1)

　　假设S不变，在S中搜索T=“abbabd”呢？答：这种情况当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]=0，意思是S[2]已经和T[2]比较过了，不相等，接下来去比较S[2]和T[0]吧。（b与首字符不同，所以只能是k或者0，且不满足条件（3）,所以为0）

　　假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢？答：这种情况当比较到S[5]和T[5]时，发现不等，就去看next[5]的值，next[5]=2，意思是前面的比较过了，其中，S[5]的前面有两个字符和T的开始两个相等，接下来去比较S[5]和T[2]吧。（d与首字符不同，所以只能是k或者0，d前面2个可以匹配前2的字符，且d与前面的字符均不相等，所以为2）

　　总之，有了串的next值，一切搞定。那么，怎么求串的模式函数值next
呢？（本文中next值、模式函数值、模式值是一个意思。）

三. 怎么求串的模式值next


定义：

（1）next[0]= -1 意义：任何串的第一个字符的模式值规定为-1。

（2）next[j]= -1 意义：满足下列条件之一：

　　(a)T[j]=T[0]，j的前面的k个字符与开头的k个字符不等

　　(b)T[j]=T[0]，j的前面的k个字符与开头的k个字符相等，但T[k]=T[j]=T[0]（1≤k<j）

　　如：T=”abCabCad” 则 next[6]= -1，因T[3]=T[6]

（3）next[j]=k 意义：j的前面k个字符与开头的k个字符相等，且T[k] != T[j] （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[k] != T[j].（1≤k<j）;

（4） next[j]=0 意义：除（1）（2）（3）的其他情况。

总结：T[j]=T[0]，看情况（2）： 前k个不等-->属于情况（2），next[j]=-1;

　　　　　　　　　　　　　　　　　　　前k个相等：T[k]=T[0]-->属于情况（2），next[j]=-1;

　　　　　　　　　　　　　　　　　　　　　　　　 T[k]!=T[0]-->情况（3），next[j]=k

　　　T[j]!=T[0]，则只可能是（3）（4）：前k个相等，T[k] != T[j]-->情况（3），next[j]=k

　　　　　　　　　　　　　　　　　　　　　　　　　　　其他-->情况（4）,next[j]=0（包括前K个相等，T[k] = T[j]，T[j]!=T[0]的情况）

举例：

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)中的(a)

next[4]=1 根据 (3) T[0]=T[3] 且 T[1]!=T[4]

若T=“abcab”将是这样：

next[0]=-1,情况（1）

next[1]=0;T[1]!=T[0]，且前k个字符不等，情况（4）

next[2]=0;T[2]!=T[0]，且前k个字符不等，情况（4）

next[3]=-1;T[3]=T[0]，且前k个字符不等，情况（2）中的（a）

next[4]=0 ;T[4]!=T[0]，且前1个字符相等T[0]=T[3]，但T[1]=T[4]不符合（3）,只能是情况（4）

02）来个复杂点的，求T=”ababcaabc” 的模式函数的值。

next[0]=-1，情况（1）

next[1]=0，情况（4）

next[2]=-1，情况（2）

next[3]=0，情况（4）

next[4]=2

next[5]=-1，情况（2）中的（a）

next[6]=1，不符合情况（2）中的（b）；属于情况（3）

next[7]=0

next[8]=2

03) 来个特殊的，求 T=”abCabCad” 的模式函数的值。

next[0]=-1

next[1]= 0

next[2]= 0

next[3]= -1

next[4]= 0

next[5]= 0

next[6]= -1

next[7]= 4。根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]

若T[4]==T[7]，即T=” adCadCad”,那么将是这样：next[7]=0,因为T[4]==T[7].

如果你觉得有点懂了，那么

练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。

意义：

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. 其他值，不可能。

四. JAVA代码

/article/2945902.html

/* KMP算法，通过测试
* Java实现KMP算法
* 思想：每当一趟匹配过程中出现字符比较不等，不需要回溯i指针，
* 而是利用已经得到的“部分匹配”的结果将模式向右“滑动”尽可能远
* 的一段距离后，继续进行比较。
* 时间复杂度O(n+m)
*/
public class KMP{
public static void main(String[] args) {
String s = "abbabbbbab"; // 主串
String t = "bbab"; // 模式串
char[] ss = s.toCharArray();
char[] tt = t.toCharArray();
System.out.println(KMP_Index(ss, tt)); // KMP匹配字符串
}
//t串的模式值next
public static int[] next(char[] t) {
int[] next = new int[t.length];
next[0] = -1;
int i = 0;
int j = -1;
while (i < t.length - 1) {
if (j == -1 || t[i] == t[j]) {
i++;
j++;
if (t[i] != t[j]) {
next[i] = j;
} else {
next[i] = next[j];
}
} else {
j = next[j];
}
}
return next;
}

//若匹配成功，返回下标，否则返回-1
public static int KMP_Index(char[] s, char[] t) {
int[] next = next(t);
int i = 0;
int j = 0;
while (i <= s.length - 1 && j <= t.length - 1) {
if (j == -1 || s[i] == t[j]) {
i++;
j++;
} else {
j = next[j];
}
}
if (j < t.length) {
return -1;
} else
return i - t.length; // 返回模式串在主串中的头下标
}
}