模式匹配的一种改进算法----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 |