KMP算法 感悟
2010-04-16 07:32
232 查看
先说下我的教材：数据结构--c语言描述（耿国华 主编）
第四章 串
其中有个模式匹配算法，一般的算法看懂之后，在网上找了KMP算法看，看了老长时间才看明白，真高兴，和大家分享下
首先，回顾一下一般的算法：
#define MAXLEN 40
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
char ch[MAXLEN];
int len;
}sstring;
int strindex(sstring S,sstring T,int pos)
{
int i,j,start;
if(T.len==0)
return 0;
start=pos;
i=start;
j=0;
while(i<S.len && j<T.len)
if(S.ch[i]==T.ch[j])
{
i++;
j++;
}
else
{
start++;
i=start;
j=0;
}
if(j==T.len)
return start;
else
return -1;
}
下面介绍传说中的ＫＭＰ算法：
ＫＭＰ算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此称之为KMP算法。此算法可以在O(n+m)
的时间数量级上完成串的模式匹配操作，其基本思想是：每当匹配过程中出现字符串比较不等时，不需回溯指针，而是利用已经得到的“部分匹配”结果将模式向右
“滑动”尽可能远的一段距离，继续进行比较。
在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的字符，如果与首字符相同，且j的前面的1—k个字符与开头的1—k个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]
（3）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （０≤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].（０≤k<j）;
举例：
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” 的模式函数值，并用后面的求模式函数值函数验证。
意义：
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]相等吗？
第四章 串
其中有个模式匹配算法，一般的算法看懂之后，在网上找了KMP算法看，看了老长时间才看明白，真高兴，和大家分享下
首先，回顾一下一般的算法：
#define MAXLEN 40
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
char ch[MAXLEN];
int len;
}sstring;
int strindex(sstring S,sstring T,int pos)
{
int i,j,start;
if(T.len==0)
return 0;
start=pos;
i=start;
j=0;
while(i<S.len && j<T.len)
if(S.ch[i]==T.ch[j])
{
i++;
j++;
}
else
{
start++;
i=start;
j=0;
}
if(j==T.len)
return start;
else
return -1;
}
下面介绍传说中的ＫＭＰ算法：
ＫＭＰ算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此称之为KMP算法。此算法可以在O(n+m)
的时间数量级上完成串的模式匹配操作，其基本思想是：每当匹配过程中出现字符串比较不等时，不需回溯指针，而是利用已经得到的“部分匹配”结果将模式向右
“滑动”尽可能远的一段距离，继续进行比较。
在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的字符，如果与首字符相同，且j的前面的1—k个字符与开头的1—k个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]
（3）next[j]=k 意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （０≤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].（０≤k<j）;
举例：
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]
即
| 下标 | 0 | 1 | 2 | 3 | 4 |
| T | a | b | c | a | c |
| next | -1 | 0 | 0 | -1 | 1 |
| 下标 | 0 | 1 | 2 | 3 | 4 |
| T | a | b | c | a | b |
| next | -1 | 0 | 0 | -1 | 0 |
根据 (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]
即
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| T | a | b | a | b | c | a | a | b | c |
| next | -1 | 0 | -1 | 0 | 2 | -1 | 1 | 0 | 2 |
-1，next[8]=2，而不是= 0，其他的好象都容易理解。
03) 来个特殊的，求 T=”abCabCad” 的模式函数的值。
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| T | a | b | C | a | b | C | a | d |
| next | -1 | 0 | 0 | -1 | 0 | 0 | -1 | 4 |
虽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].
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| T | a | d | C | a | d | C | a | d |
| next | -1 | 0 | 0 | -1 | 0 | 0 | -1 | 0 |
练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。
意义：
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]相等吗？
下面是我写的ｃ语言代码，供大家参考：
#define MAXLEN 40
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
char ch[MAXLEN];
int len;
}sstring;
int index_kmp(sstring S,sstring T,int pos)
{
int a=0,b=1,next[T.len];
next[0]=-1;
while(T.ch[b]!='/0')
{
if(T.ch[b]!=T.ch[b])
{ //此处（下三行）为缩写,原式为：
next[b]=a; // if(a==0)
a=0; //{
b++; // next[b]=a;
} // b++;
else //}
{ //else
next[b]=-1; //{
a++; // next[b]=a;
b++; // a=0;
} // b++;
} //}
a=pos;
b=0;
while(S.ch[a+b]!='/0' && T.ch[b]!='/0')
if(S.ch[a+b]==T.ch[b])
b++;
else
{
if(next[b]!=-1)
b=next[b];
else
{
a++;
b=0;
}
}
if(b==T.len)
return a;
else
return -1;
}
int main()
{
sstring a={"abcabcabd",9},b={"abd",3};
printf("%d/n",index_kmp(a,b,0));
system("pause");
return 0;
}
哈哈，今天刚看懂的，不知道有没有错误，如果有，请高手指正哈。
参考资料：
感谢axlrosek河马王凯的文章http://blog.csdn.net/axlrosek/archive/2007/07/08/1683066.aspx
我就是看这个看懂的，也引用了很多部分。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- KMP算法做题感悟。
- KMP算法——初学者的一点感悟
- KMP算法学习之（一）学习的感悟
- KMP算法和状态机的联系
- 关于对象数据封装的一点感悟
- ACM学习感悟
- [程序猿感悟] 一个当了爹的程序员的自白，多些业余生活，更能提高效率
- KMP算法
- 写程序中的感悟
- 感悟_2012-11-18
- 感悟dota 成就人生
- KMP算法--c语言源代码
- 三年程序员生涯的感悟、总结和憧憬
- 个人技术生涯的感悟(1)
- 经典算法题每日演练——第七题 KMP算法
- 对学习的感悟
- kmp算法源码-经过比较，这个源码的速度应该是移动最快的。
- 关于对CDR处理的一点感悟（存储过程）
- 老男孩在创业及培训中28条教导学生感悟语录分享！
- 人生之离别感悟