字符串模式匹配算法1 - BF和KMP算法

 

在字符串S中定位/查找某个子字符串P的操作,通常称为字符串的模式匹配,其中P称为模式串。模式匹配有多种算法,这里先总结一下BF算法和KMP算法。

注意:本文在讨论字符位置/指针/下标时,全部使用C语法,即下标从0开始。

BF算法

BF(Brute Force)算法也就是传说中的“笨办法”,是一个暴力/蛮力算法。设串S和P的长度分别为m,n,则它在最坏情况下的时间复杂度是O(m*n)。BF算法的最坏时间复杂度虽然不好,但它易于理解和编程,在实际应用中,一般还能达到近似于O(m+n)的时间度(最坏情况不是那么容易出现的,RP问题),因此,还在被大量使用。

下面举例来说明BF算法的思想。

设S=‘ababcabcacbab’, P=‘abcac’,从S的第1个字符开始,依次比较S和P中的字符,如果没有完全匹配,则从S第2个字符开始,再次比较…如此重复,直到找到P的完全匹配或者不存在匹配。用数学语言描述,就是比较SiSi+1…Si+n-1和P0P1…Pn-1,如果出现不匹配,则令i=i+1,继续这一过程,直到全部匹配,或者i>(m-n)。匹配过程如下(红色字体表示本趟比较中不匹配的字符):

第1趟
S: a b a b c a b c a c b a b
P: a b c 

第2趟
S: a b a b c a b c a c b a b
P:   a

第3趟
S: a b a b c a b c a c b a b
P:     a b c a c

第4趟
S: a b a b c a b c a c b a b
P:       a

第5趟

S: a b a b c a b c a c b a b
P:         a

第6趟

S: a b a b c a b c a c b a b
P:           a b c a c

 以下是实现与测试的C代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// BF (Brute Force) algorithm
// worst time complexity : O(m*n)
static int bf (const char*, const char*);
static int bf2(const char*, const char*);

int main(void)
{
    char* str = "ababcabcacbab";
    char* ptn = "abcac";

    printf("match1 at %d\n", bf(str, ptn));
    printf("match2 at %d\n", bf2(str, ptn));

    return 0;
}

int bf(const char* _str, const char* _ptn)
{
    int m, n, i, j;

    m = strlen(_str);
    n = strlen(_ptn);

    i = 0; j = 0;
    while(i<m && j<n)
    {
        if(_str[i] == _ptn[j])
        {
            printf("OK %d %d %c %c\n", i, j, _str[i], _ptn[j]);
            ++i;  ++j; 
        }
        else
        {
            printf("NO %d %d %c %c\n", i, j, _str[i], _ptn[j]);
            i = i-j+1; j = 0; 
        }
    }

    if(j >= n)
        return i-n;
    else
        return -1;
}



int bf2(const char* _str, const char* _ptn)
{
    int m, n, i, j;

    m = strlen(_str);
    n = strlen(_ptn);

    i = 0; j = 0;
    for(i=0; i<=(m-n); ++i)
    {
        for(j=0; j<n; ++j)
        {
            if(_str[i+j] != _ptn[j])
            {
                printf("NO %d %d %c %c\n", i+j, j, _str[i+j], _ptn[j]);
                break;
            }
            else
                printf("OK %d %d %c %c\n", i+j, j, _str[i+j], _ptn[j]);
        }
        if(n == j)  return i;
    }

    return -1;
}

 

BF算法的问题

BF算法在某些情况下存在效率上的问题。比如当S=‘aaaaaaabab’, P=‘aaab’时,BF算法匹配如下:

第1趟
S: a a a a a a a b a b
P: a a a b

第2趟
S: a a a a a a a b a b
P:   a a a b

第3趟
S: a a a a a a a b a b
P:     a a a b

第4趟
S: a a a a a a a b a b
P:       a a a b

第5趟
S: a a a a a a a b a b
P:         a a a b

若以i,j分别代表S串和P串当前比较的字符的位置/指针,那么(结合bf2函数))可以看出BF算法在每一趟匹配失败后,i,j均要回退——j回退到0,i回退到i-j+1——再继续下一趟比较(注意这里的i不是bf2函数里的i,而是相当于i+j)。而对以上特例来说,比如在第1趟比较后,S3!=P3事实上我们已经知道S1S2==‘aa’,因此不需要回退i,比较S1和P0, S2和P0,而只需回退j,比较S3和P2。这样的话,由于i没有回退,也就是减少了bf2中的外层循环次数,从而提高了匹配效率。如下图所示,图中↓表示当前指针i的位置。

         ↓
S: a a a a a a a b a b
P: a a a b       
        
->           
           ↓
S: a a a a a a a b a b
P:   a a a b                 
         ->             
             ↓
S: a a a a a a a b a b
P:     a a a b                       
         ->               
               ↓
S: a a a a a a a b a b
P:       a a a b       
         ->                 
                 ↓
S: a a a a a a a b a b
P:         a a a b

 

KMP算法

上面的改进算法就是KMP算法,它是由D.E.Knuth、J.H.Morris和V.R.Pratt同时发现的。KMP算法可以在O(m+n)的时间里完成串的模式匹配。它的主要思想是:每当一趟匹配过程中出现字符不匹配时,不需回退i指针,而是利用已经得到的“部分匹配”的结果将模式向右“滑动”尽可能远的一段距离后,继续匹配过程。

仍以一开始的例子S=‘ababcabcacbab’, P=‘abcac’来再看一遍KMP算法的匹配过程:

第1趟
            ↓ i=2
S: a b a b c a b c a c b a b
P: a b c 

第2趟
                         ↓ i=6
S: a b a b c a b c a c b a b

P:     a b c a c

第3趟 
                                    ↓ i=10
S: a b a b c a b c a c b a b
P:          (a)b c a c

第1趟正常比较,S2和P2不匹配,而且发现S1!=P0,因此,第2趟比较时,就不需要比较S1和P0了,i指针保持不动,只需将j指针向右滑动1个位置,直接比较S2和P1即可;

第2趟比较时,S6和P4不匹配,而且发现S3==’b’,S4==’c’,均与P0==’a’不匹配,因此,不需要进行以S3与P0、 S4和P0比较开始的这两趟。另外,又现S5==’a’==P0,因此,也不需要回退i指针,只需将j指针向右滑动一个位置,直接比较P6与P1即可。与本文开头的BF算法相比,KMP仅外层循环就减少为3趟,大大提升了匹配效率。

把上例的讨论推广到一般情况,设主串S=‘S0S1…Sm’,模式串P=’P0P1…Pn‘,那么我们要解决的问题可表述为:当匹配过程中产生“失配”(即不相等)时,模式串“向右滑动”的距离应该是多少?或者说,当Si!=Pj时,Si应该和P中的哪个字符继续比较?注意,主串的字符指针i不回退。

假设此时Si应和Pk(k<j)继续比较,则k必满足以下条件,且k是满足此条件的最大值,即不存在k'(k<k'<j)也满足此条件:

P0P1…Pk-1 == Si-kSi-k+1…Si-1               (1)

此时实际已得到的“部分匹配”结果是:

Pj-kPj-k+1…Pj-1 == Si-kSi-k+1…Si-1          (2)

由(1)、(2)两式,可推得:

P0P1…Pk-1== Pj-kPj-k+1…Pj-1                          (3)

反过来讲,如果在匹配过程中,有Si!=Pj,且有满足(3)式的k(k<j)存在时,则i不动,只需继续比较Si和Pk即可;如果k不存在,则继续比较Si和P0。注意,k仅与模式P有关 ,而和主串S无关。

条件(3)表达了KMP算法的精髓之一。在主串指针i不移动的情况下,我们就是根据当前模式串指针j是否存在一个满足条件(3)的k,来决定模式串“向右滑动”的距离:

a.如果存在这个k,也就是说,失配的Pj前存在一个长度为k(0<k<j)的子串,它与模式串P开头的前k个字符组成的子串相同,或者叫“重叠”。而且,这个k是满足此条件的“最大的”k,如果使用了可能的“较小的”k进行继续比较,将会出现不必要的匹配过程。

b.如果k不存在,那么就从P0开始继续比较。

要注意,如果存在k,就必须比较Pk与Si,不能比较P0与Si,否则将会出错。比如当:

S: a a a a a a a b a b
P:       a a a b  

此时失配的i=6,j=3, 而k=2,(k需满足0<k<j),下趟应比较S6与P2,如果无视k的存在,去比较S6与P0,就出错了,找不到匹配:

S: a a a a a a a b a b
P:             a a a  

 

从(3)式及其附近的表述,我们已经知道k的值与主串无关,仅与模式串本身有关,因此,我们可以把k表示为模式串位置/指针j的函数next(j): 

next(j) = Max {k | 0<k<j,且P0P1…Pk-1== Pj-kPj-k+1…Pj-1 } ,k存在时
       或 = 0,k不存在时

举个例子,当P=‘abaabcac’时,其各位置的next值计算过程为:

a  j=0, next(j)=0
b  j=1, 满足0<k<1的整数k不存在,next(j)=0
a  j=2, 子串P1 != P0,k不存在,next(j)=0
a  j=3, 存在且仅存在子串P2==P0,next(j)=k=1
b  j=4, 存在且仅存在子串P3==P0,next(j)=k=1
c  j=5, 存在最大子串P3P4==P0P1,next(j)=k=2
a  j=6, 不存在要求子串,next(j)=0
c  j=7, 存在且仅存在子串P6==P0,next(j)=k=1

求得模式串的next函数后,KMP算法的匹配过程如下:

以指针i和j分别指示主串和模式串中当前要比较的字符,若在匹配过程中Si==Pj,则i和j分别增1;否则,i不变(不回退),而j回退到next(j),继续进行比较:若匹配,则i,j分别增1,否则,j继续回退到下一个next(j),如此类推。直到以下两种可能:

  •  j回退到某个next(j)时 {next(next(…next(j)…)) },Si==Pj,则i,j分别增1;
  •  j退到0,即与模式串中第一个字符也不匹配,此时需要将i增1,j不变,即比较Si+1和Pj

KMP算法代码如下:

 1 int kmp(const char* _str, const char* _ptn)
 2 {
 3     size_t m = strlen(_str);
 4     size_t n = strlen(_ptn);
 5     size_t i = 0, j = 0;
 6 
 7     size_t loop = 0;
 8     
 9     int* next = (int*)malloc(n*sizeof(int));
10     memset(next, 0, n*sizeof(int));
11     //kmp_next(_ptn, next);
12     kmp_next2(_ptn, next);
13 
14     for(i=0; i<n; ++i)
15         printf("%d ", next[i]);
16     printf("\n");
17 
18     i = 0; j = 0;
19     while(i < m && j < n)
20     {
21         loop++;
22         if(_str[i] == _ptn[j])
23             { ++i; ++j; }
24         else if(0 == j)
25             ++i;
26         else
27             j = next[j];
28     }
29 
30     free(next); next = NULL;
31 
32     printf("loop: %ld\n", loop);
33 
34     if(j >= n)
35         return i-n;
36     else
37         return -1;
38 }

 

求next函数值

求next(j)的一种方法是递推法。

首先由定义可知next(0) = 0。若令next(j) = k,则模式P中存在下列关系:

P0P1…Pk-1== Pj-kPj-k+1…Pj-1   (1<k<j,且不存在k’>k满足此条件)

此时我们需要递推求得next(j+1)的值。分两种情形:

  • 若Pk==Pj,则根据next函数定义,有next(j+1) == k+1 == next(j) + 1
  • 若pk!=Pj,这时可以应用KMP算法的思想,并把模式串本身既看成主串,又看成模式串,那么问题就转化成一般的KMP算法问题。根据KMP算法,这时,应把第next(k)个字符与Pj进行比较。若Pj==Pnext(k) ,则next(j+1) == next(k)+1;若Pj != Pnext(k),则继续比较Pj和Pnext(next(k)) ……依此类推,直至Pj和某个字符匹配成功。或者不存在任何k’(1<k'<k<j)可以匹配成功,则令next(j+1)=0。

求next函数值的代码如下:

 1 void kmp_next(const char* _ptn, int* _next)
 2 {
 3     size_t n = strlen(_ptn);
 4     size_t i, j;
 5 
 6     if(n >= 1)
 7         _next[0] = 0;
 8 
 9     i = 1; j = 0;
10     while(i < n)
11     {
12         if(_ptn[i] == _ptn[j])
13             _next[++i] = ++j;
14         else if(0 == j)
15             _next[++i] = j;
16         else
17             j = _next[j];
18     }
19 }

 

next函数的改进

以上的next函数值求法对于某些情况会有一些不足。比如当S=‘aaabaaaab’,P=‘aaaab’时,进行到以下匹配:

S: a a a b a a a a b
P: a a a a b

发生失配S3!=P3。此时,如果按之前的next函数值求法,会得到next(1)==0, next(2)==1, next(3)==2,那么根据KMP算法,S3会与Pnext(3)即P2进行比较;发现不匹配,那么模式串各右滑动,S3继续与Pnext(2)即P1进行比较;发现还不匹配,继续向右滑动模式串,S3继续与Pnext(1)即P0进行比较,发现仍不匹配,没办法,才会将S串上的i指针增1,让S4与P0比较。

然而,由于P0,P1,P2和P3相等,既然S3!=P3,那么根本没必要进行接下来的比较了,i指针可以直接增1,进行下边的比较。推广到一般情况来说,就是如果这样的情况发生,我们要人为地让j的回退幅度更大,以减少不必要的比较。 根据这个发现,我们可以对next函数的递推求值算法的情形1进行优化:

若Pk==Pnext(j)==Pj时,恰满足Pk+1==Pnext(j)+1==Pj+1,那么当Pj+1失配时,不需要比较Pnext(j)+1和Pj+1,即next(j+1)不用取next(j)+1,而可以将模式串中要比较的位置再向左移,到next(j+1) = next(next(j+1))。

《字符串模式匹配算法1 - BF和KMP算法》

 正如上图所示,由于Pj+1==Pk+1,next(j+1)的值可以跨过k+1,而直接到k’==next(k+1),即next(j+1) = next(k+1) == next(next(j+1))。

 改进后的next函数代码如下:

 1 void kmp_next2(const char* _ptn, int* _next)
 2 {
 3     size_t n = strlen(_ptn);
 4     size_t i, j;
 5     
 6     if(n >= 1)
 7         _next[0] = 0;
 8     
 9     i = 1; j = 0;
10     while(i < n)
11     {
12         if(_ptn[i] == _ptn[j])
13         {
14             ++i; ++j;
15             if(_ptn[i] != _ptn[j])
16                 _next[i] = j;
17             else
18                 _next[i] = _next[j];
19         }
20         else if(0 == j)
21             _next[++i] = j;
22         else
23             j = _next[j];
24     }
25 }

 

【参考资料】

《数据结构(C语言版)》,严蔚敏 吴伟民 编著,清华大学出版社。

 

    原文作者:赵子清
    原文地址: https://www.cnblogs.com/zzqcn/p/3508442.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注