模式匹配 -- KMP 算法原理与实现

 

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