本文深入讲解KMP算法的原理及应用，包括next和nextval数组的计算方法，并提供了详细的代码实例。
模式匹配的一种改进算法----KMP算法
这种改进算法是D.E.Knuth与V.R.Pratt和J.H.Morris同时发现的，因此人们称它为克努特-莫里斯-普拉特算法（简称为KMP算法）。该算法可以在O(n+m)的时间数量级上完成串的模式匹配操作。其改进在于：每当一趟匹配过程中出现字符比较不等时，不需回溯i指针，而是利用已经得到的‘部分匹配’的结果将模式向右‘滑动’尽可能远的一段距离后，继续进行比较。一般情况下，假设主串为s0s1…sn-1，模式串为p0p1…pm-1，从上例的分析可知，为了实现改进算法，需要解决下述问题：当匹配过程中产生“失配”（即si≠pj）时，模式串“向右滑动”可行的距离有多远，换句话说，当主串中字符Si与模式中字符Pj “失配”（即比较不等）时，主串中字符Si（i指针不回溯）应与模式中哪个字符再比较？
假设此时主串中字符Si应与模式中字符Pk（k＜j）继续比较，则模式中字符Pk前面k个字符的子串必须满足下列关系式（f-1），且不存在k'＞k满足下列关系式
p0p1…pk-1= si-ksi-k+1…si-1 （f-1）
当主串中字符Si与模式中字符Pj “失配”时，已经得到的“部分”匹配结果是：
pj-kpj-k+1…pj-1= si-ksi-k+1…si-1 （f-2）
由（f-1）和（f-2）推得下列等式
p0p1…pk-1 = pj-kpj-k+1…pj-1 (f-3)
我们称"p0p1…pk-1"为"p0p1p2…pj-2pj-1"的前缀子串，"pj-kpj-k+1…pj-1"为"p0p1p2…pj-2pj-1"的后缀子串。
若模式串中存在真子串"p0p1…pk-1= pj-kpj-k+1…pj-1"，且满足0<k<j,则当匹配过程中，主串中字符Si与模式中字符Pj比较不等时，仅需将模式向右滑动至模式中第k个字符和主串中字符Si对齐，此时，模式中头k个字符的子串"p0p1…pk-1"必定与主串中字符Si之前长度为k的子串"si-ksi-k+1…si-1"相等。由此，匹配仅需从模式中Pk与主串中字符Si比较起继续进行。 若令next[j]=k,则next[j]表明当模式中第j个字符与主串中相应字符“失配”时，在模式中需重新和主串中该字符进行比较的字符的位置。由此可引出模式串的next函数的定义： 1.next[j]=-1 当j=0时 2.next[j]=Max{k|0<k<j且"p0p1…pk-1= pj-kpj-k+1…pj-1"} 此集合不为空时 3.next[j]=1 其他情况 其中p0p1…pk-1为p0p1p2…pj-2pj-1的前缀子串，pj-kpj-k+1…pj-1为p0p1p2…pj-2pj-1的后缀子串。
KMP算法源代码如下：
#include <stdio.h>
#include <string.h>
#define MAXSIZE 100
void get_nextval(unsigned char pat[],int nextval[])
{
int length = strlen(pat);
int i=1;
int j=0;
nextval[1]=0;
while(i<length)
{
if(j==0||pat[i-1]==pat[j-1])
{
++i;
++j;
if(pat[i-1]!=pat[j-1]) nextval[i]=j;
else nextval[i]=nextval[j];
}
else j=nextval[j];
}
}
int Index_KMP(unsigned char text[], unsigned char pat[],int nextval[])
{
int i=1;
int j=1;
int t_len = strlen(text);
int p_len = strlen(pat);
while (i<=t_len&&j<=p_len)
{
if(j==0||text[i-1]==pat[j-1]){++i;++j;}
else j=nextval[j];
}
if (j>p_len) return i-1-p_len;
else return -1;
}
int main()
{
unsigned char text[MAXSIZE];
unsigned char pat[MAXSIZE];
int nextval[MAXSIZE];
int answer, i; printf("/nBoyer-Moore String Searching Program");
printf("/n====================================");
printf("/n/nText String --> ");
gets(text);
printf( "/nPattern String --> ");
gets(pat);
get_nextval(pat,nextval);
if((answer=Index_KMP(text, pat,nextval))>=0)
{
printf("/n");
printf("%s/n", text);
for (i = 0; i < answer; i++)
printf(" ");
printf("%s", pat);
printf("/n/nPattern Found at location %d/n", answer);
}
else
printf("/nPattern NOT FOUND./n"); return 0;
}
Next[]数组求法
实际上Linux 内核从2.6.14开始就引入了名为string的iptables匹配(match)模块，它提供有KMP、BM(Boyer-Moore)和FSM(finite state machine)算法，可以实现基于关键字的网络过滤。这里引用一下Linux内核中的实现代码，以供参考。
#include <assert.h>
#include <stdio.h>
void kmp_init(const char *patn, int len, int *next)
{
int i, j;
assert(patn != NULL && len > 0 && next != NULL);
next[0] = 0;
for (i = 1, j = 0; i < len; i ++) {
while (j > 0 && patn[j] != patn[i])
j = next[j - 1];
if (patn[j] == patn[i])
j ++;
next[i] = j;
}
}
int kmp_find(const char *text, int text_len, const char *patn,
int patn_len, int *next)
{
int i, j;
assert(text != NULL && text_len > 0 && patn != NULL && patn_len > 0
&& next != NULL);
for (i = 0, j = 0; i < text_len; i ++ ) {
while (j > 0 && text[i] != patn[j])
j = next[j - 1];
if (text[i] == patn[j])
j ++;
if (j == patn_len)
return i + 1 - patn_len;
}
return -1;
}
int main(int argc, char *argv[])
{
int *next;
int i, pos, len = strlen(argv[2]);
if (argc < 3) {
printf("Usage: %s text pattern/n", argv[0]);
return 1;
}
next = calloc(strlen(argv[2]), sizeof(int));
kmp_init(argv[2], strlen(argv[2]), next);
printf("next array:/n");
for (i = 0; i < len; i ++)
printf("/t%c", argv[2][i]);
printf("/n");
for (i = 0; i < len; i ++)
printf("/t%d", next[i]);
printf("/n");
pos = kmp_find(argv[1], strlen(argv[1]), argv[2], strlen(argv[2]), next);
printf("find result:/n");
if (pos < 0) {
printf("None found!/n");
} else {
printf("%s/n", argv[1]);
for (i = 0; i < pos; i ++)
printf(" ");
printf("^/n");
}
return 0;
}
参考资料:
http://www.yuanma.org/data/2009/0916/article_3909.htm
http://www.yuanma.org/data/2007/0420/article_2535.htm
例如：
| 模式串 | a | b | a | a | b | c | a | c |
| next值 | 0 | 1 | 1 | 2 | 2 | 3 | 1 | 2 |
| nextval值 |
|
|
|
|
|
|
|
|
next数组的求解方法是：第一位的next值为0，第二位的next值为1，后面求解每一位的next值时，根据前一位进行比较。首先将前一位与其next值对应的内容进行比较，如果相等，则该位的next值就是前一位的next值加上1；如果不等，向前继续寻找next值对应的内容来与前一位进行比较，直到找到某个位上内容的next值对应的内容与前一位相等为止，则这个位对应的值加上1即为需求的next值；如果找到第一位都没有找到与前一位相等的内容，那么需求的位上的next值即为1。
看起来很令人费解，利用上面的例子具体运算一遍。
1.前两位必定为0和1。
2.计算第三位的时候，看第二位b的next值，为1，则把b和1对应的a进行比较，不同，则第三位a的next的值为1，因为一直比到最前一位，都没有发生比较相同的现象。
3.计算第四位的时候，看第三位a的next值，为1，则把a和1对应的a进行比较，相同，则第四位a的next的值为第三位a的next值加上1。为2。因为是在第三位实现了其next值对应的值与第三位的值相同。
4.计算第五位的时候，看第四位a的next值，为2，则把a和2对应的b进行比较，不同，则再将b对应的next值1对应的a与第四位的a进行比较，相同，则第五位的next值为第二位b的next值加上1，为2。因为是在第二位实现了其next值对应的值与第四位的值相同。
5.计算第六位的时候，看第五位b的next值，为2，则把b和2对应的b进行比较，相同，则第六位c的next值为第五位b的next值加上1，为3，因为是在第五位实现了其next值对应的值与第五位相同。
6.计算第七位的时候，看第六位c的next值，为3，则把c和3对应的a进行比较，不同，则再把第3位a的next值1对应的a与第六位c比较，仍然不同，则第七位的next值为1。
7.计算第八位的时候，看第七位a的next值，为1，则把a和1对应的a进行比较，相同，则第八位c的next值为第七位a的next值加上1，为2，因为是在第七位和实现了其next值对应的值与第七位相同。
在计算nextval之前要先弄明白，nextval是为了弥补next函数在某些情况下的缺陷而产生的，例如主串为“aaabaaaab”、模式串为“aaaab”那么，比较的时候就会发生一些浪费的情况：比较到主串以及模式串的第四位时，发现其值并不相等，据我们观察，我们可以直接从主串的第五位开始与模式串进行比较，而事实上，却进行了几次多余的比较。使用nextval可以去除那些不必要的比较次数。
求nextval数组值有两种方法，一种是不依赖next数组值直接用观察法求得，一种方法是根据next数组值进行推理，两种方法均可使用，视更喜欢哪种方法而定。
我们使用例子“aaaab”来考查第一种方法。
1.试想，在进行模式匹配的过程中，将模式串“aaaab”与主串进行匹配的时候，如果第一位就没有吻合，即第一位就不是a，那么不用比较了，赶快挪到主串的下一位继续与模式串的第一位进行比较吧，这时，模式串并没有发生偏移，那么，模式串第一位a的nextval值为0。
2.如果在匹配过程中，到第二位才发生不匹配现象，那么主串的第一位必定是a，而第二位必定不为a，既然知道第二位一定不为a，那么主串的第一、二两位就没有再进行比较的必要，直接跳到第三位来与模式串的第一位进行比较吧，同样，模式串也没有发生偏移，第二位的nextval值仍然为0。
3.第三位、第四位类似2的过程，均为0。
4.如果在匹配过程中，直到第五位才发生不匹配现象，那么主串的第一位到第四位必定为a，并且第五位必定不为b，可是第五位仍然有可能等于a。如果万一第五位为a，那么既然前面四位均为a，所以，只要第六位为b，第一个字符串就匹配成功了。所以，现在的情况下，就是看第五位究竟是不是a了。所以发生了下面的比较：
| 1 | 2 | 3 | 4 | 5 | 6 |
| a | a | a | a | * | * |
| a | a | a | a | b |
|
|
| a | a | a | a | b |
前面的三个a都不需要进行比较，只要确定主串中不等于b的那个位是否为a，即可以进行如下的比较：如果为a，则继续比较主串后面一位是否为b；如果不为a，则此次比较结束，继续将模式串的第一位去与主串的下一位进行比较。由此看来，在模式串的第五位上，进行的比较偏移了4位（不进行偏移，直接比较下一位为0），故第五位b的nextval值为4。
我们可以利用第一个例子“abaabcac”对这种方法进行验证。
a的nextval值为0，因为如果主串的第一位不是a，那么没有再比较下去的必要，直接比较主串的第二位是否为a。如果比较到主串的第二位才发生错误，则主串第一位肯定为a，第二位肯定不为b，此时不能直接跳到第三位进行比较，因为第二位还可能是a，所以对主串的第二位再进行一次比较，偏移了1位，故模式串第二位的nextval值为1。以此类推，nextval值分别为：01021302。其中第六位的nextval之所以为3，是因为，如果主串比较到第六位才发生不匹配现象，那么主串的前五位必定为“abaab”且第六位必定不是“c”，但第六位如果为“a”的话，那么我们就可以从模式串的第四位继续比较下去。所以，这次比较为：
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| a | b | a | a | b | * | * | * | * | * | * | * |
|
|
|
| a | b | a | a | b | c | a | c |
|
而不是：
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| a | b | a | a | b | * | * | * | * | * | * | * |
|
|
|
|
|
| a | b | a | a | b | c | a |
因为前两位a和b已经确定了，所以不需要再进行比较了。所以模式串第六位的nextval值为这次比较的偏移量3。
再来看求nextval数组值的第二种方法。
| 模式串 | a | b | a | a | b | c | a | c |
| next值 | 0 | 1 | 1 | 2 | 2 | 3 | 1 | 2 |
| nextval值 | 0 | 1 | 0 | 2 | 1 | 3 | 0 | 2 |
1.第一位的nextval值必定为0，第二位如果于第一位相同则为0，如果不同则为1。
2.第三位的next值为1，那么将第三位和第一位进行比较，均为a，相同，则，第三位的nextval值为0。
3.第四位的next值为2，那么将第四位和第二位进行比较，不同，则第四位的nextval值为其next值，为2。
4.第五位的next值为2，那么将第五位和第二位进行比较，相同，第二位的next值为1，则继续将第二位与第一位进行比较，不同，则第五位的nextval值为第二位的next值，为1。
5.第六位的next值为3，那么将第六位和第三位进行比较，不同，则第六位的nextval值为其next值，为3。
6.第七位的next值为1，那么将第七位和第一位进行比较，相同，则第七位的nextval值为0。
7.第八位的next值为2，那么将第八位和第二位进行比较，不同，则第八位的nextval值为其next值，为2。
在“aaaab”内进行验证。
| 模式串 | a | a | a | a | b |
| next值 | 0 | 1 | 2 | 3 | 4 |
| nextval值 | 0 | 0 | 0 | 0 | 4 |
扫一扫
1314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
