关于字符串匹配算法研究

        第一篇随笔，开始写博客生涯。写程序这么长时间，突然发现也要总结与积累。原来想第一篇博文是关于以前写的代码研究，发现还需要整理。这样，先发表一篇关于字符串

匹配的文章。就这样啦！

        字符串匹配主要是关于模式串与主串匹配的问题。关于这个问题，有很多方法。网上也有不少例子，借鉴了不少，以下就介绍下面几种算法。

 

        （1）BF算法（常规算法）

         BF算法就是最笨的算法，一个一个进行匹配。这里采用后缀匹配算法。其实与正常的BF算法想法差不多。只不过为了与第四种算法相对应，就用后缀匹配算法代替BF算法。

         从网上搞些图（自己实在不想自己画图）

         

          从后面开始进行匹配。当不匹配时，子串整体向右偏移一个单位，再与主串进行比较。从而不断进行循环，直到比较到主串最后一个数。不匹配，则返回-1。否则，返回主

串开始匹配的位置。

         Source为主串，SubString为子串。

 1 int Search_Reverse(const char *Source,const char *SubString)           //后缀缀回溯比较法  （常规BF算法）---为BM算法进行铺垫
 2 {
 3   int SourceArry = strlen(Source);                                     //主串的长度
 4   int SubArry = strlen(SubString);                                     //子串的长度
 5   int pSub  ,pSour =  SubArry;                                         //定义pSub,pSour数值
 6   if(SubArry==0)
 7       return -1;
 8   while(pSour <= SourceArry)                                           //主串是否到了尽头             
 9   {   
10       pSub = SubArry;                                                  //初始化
11       while(SubString[--pSub]==Source[--pSour])                        //进行匹配比较
12     {
13        if(pSour < 0)  return -1;                                       //如果pSour,以子串长度为一组的主串扫描结束
14            
15        if(pSub == 0) return  pSour;                                    //为0,匹配成功
16 
17     }
18     pSour += (SubArry - pSub) +1 ;                                     //进行偏移,pSour值进行恢复与回溯,SubArry - pSub为以前减去的值补回
19     
20   }
21 
22   return -1;
23 
24 }

        
   

   (2)KMP算法

    KMP算法可能一开始理解有点麻烦。不过，有些时候，就要想为什么用KMP匹配算法。比如有子串“abcabd",为什么要用这算法？

   

    当主串中S[5]=“c"与子串T[5]"d"不匹配了，如果采用BF算法进行匹配，则效率偏低。采用KMP算法之后，将子串中的T[0]与主串中的S[3]对齐，再进行比较。因为在子串

中，T[0]~T[1]的字符串与T[3]~T[4]相等，那么刚才第一次匹配时，已经说明S[3]~S[4]与T[3]~T[4]相等,那么也就说明S[3]~S[4]与T[0]~T[1]相等。所以直接将S[5]与

T[2]比较，从这里开始匹配。所以在第一次匹配失败之后，决定从子串中哪个位置再开始进行比较，就是KMP算法中关于Next[]数组的设置。所以KMP算法比BF算法稍微简单一

点，因为我们对于子串做了处理，不用从有时不用从子串T[0]从头开始比较。

    基于子串关于Next[]数组的处理，如下：

     

下标i	0	1	2	3	4	5	6	7	8	9
p(i)	a	b	c	d	a	a	b	c	a	b
next[i]	-1	0	0	0	0	1	1	2	3	1

    Next[0]设置为-1，说简单一点，就是在后面找到相匹配的最大前缀。这时，T[4]与T[0]相等。则如果在这里不匹配时，则直接T[Next[4]]与S[4]再进行比较。当在S[5]时不

 

匹配时，则回退到T[Next[5]]再进行比较。所以Next数组中的数字代表这个意思，即可以回溯到哪里。如果运气好，有相同字符，可以节约一定时间。至于Next数组的算法，则可

 

以采用迭代。

 

   

    

   

也就是对于序列

找出这样一个k，使其满足

并且要求k尽可能的大！

  

 1 void NextNumber(int Next[],void*S,unsigned int ElemtSize)                    //对需要查找的字符串进行预处理
 2 {   
 3     
 4     char *ps = (char*) malloc(ElemtSize);
 5     memcpy(ps,S, ElemtSize);
 6     int i=strlen(ps);
 7     int j = 0;                       //从头开始计数的j标识
 8     int p = 1;                       //与j进行比较的标识
 9     Next[0] = -1;                    //Next[0] = -1,Next[1] = 0;
10     Next[1] = 0;
11     while(p1)                     //p
12     {
13         if(ps[p]==ps[j])   
14       {
15         Next[p+1] = j+1 ;            //最主要的区别在于，Next[]为一数组，ps又为一数组，且数组之间相差为一
16         ++p;
17         ++j;
18       }
19       else if(j==0)                  //当j为0时，Next[p+1] = 0;这个有点初始化的味道。         
20       {
21         Next[p+1] = 0;           
22         ++p;
23       
24       }
25       else 
26         j = Next[j];                 //数组适当进行回退
27     }
28       
29 }

  Next数组处理好了，接下来就是进行字符串匹配了，即主函数。
 

 1 const int Max = 100;
 2 void NextNumber(int Next[],void*S,unsigned int ElemtSize);
 3 int KMP(void*T,void*S,unsigned int ElemtSizeT,unsigned int ElemtSizeS)        //T为主串,S为子串
 4 {
 5     char *Ts = (char*) malloc(ElemtSizeT);                                    //将Void做一个转换
 6     memcpy(Ts,T,ElemtSizeT);
 7     char *Ps = (char*) malloc(ElemtSizeS);
 8     memcpy(Ps,S,ElemtSizeS);
 9     int Next[Max];
10     NextNumber(Next,S,ElemtSizeS);
11     int t = 0;
12     int s = 0;
13     int v;                                                                     //v为偏移距离
14     while(t < ElemtSizeT-1 && (s< ElemtSizeS-1)||s==-1)
15     {
16       if(s == -1|| Ts[t] == Ps[s])                                             //s为-1时，即比较从头开始,Ts为主串，Ps为子串
17       {
18           ++t;++s; 
19       }
20       else 
21        s = Next[s]; 
22       
23       if(s == ElemtSizeS-1) v = t-ElemtSizeS+1;
24       else  v = -1;
25     }
26 
27      return v;
28 }

    上述代码中，字符类型为Void*，不过下面为此做了转换。为什么用此类型，纯属作为实验，尝试用void*类型写一下，大家完全可以用char*.哈哈！

    如果还有什么不懂，尽量百度，我发现自己的表达水平果然不怎么样！

 

   (3)Rabin_Karp算法

      这个算法是从《算法导论》中借鉴过来的，主要是利用公式。相对来说，前期的工作可能比较辛苦些，主要是做一个Hash表，具体咋样？这里不具体说明。

     大概思想就是下面这个图：

     其实也就是不断增加找到匹配子串的概率，但也有可能不是，相对来说好一些。当主串中某位置计算出来的值与整个子串计算出来的值相等时，就说明可能在主串这个位置，与

子串相匹配。有这个概率，降低了比较的次数。

    算法精华在于在于首先判断出现子串首字母的地方进行标记，然后再进行判断比较

  
    算法利用到了初等算法的理论，两个数对于第三个数等价。

   

 1 int Rabin_Karp_Match( string T,string P,int d,int q)          //d为基数/q为除数,最好是一个素数(T为主串,P为子串）
 2 {
 3   int n = T.length();
 4   int m = P.length();
 5   int h = d^(m-1);
 6   int v  ;                                                     //v为返回值（-1）为失败,其他v值代表匹配的偏移量
 7   int p = 0;
 8   int t[Max];
 9   t[0] = 0;
10   for(int i=0;ii)
11   {
12      p=(d*p+P[i])%q;                                          //整个子串计算出来的值
13      t[0]=(d*t[0] +T[i])%q;                                   //t0为T主串首个开始点，方便后面用迭代
14   }
15   for(int j=0;jj)
16   {
17       if(p==t[j])
18           for(int s=0;ss)
19           { 
20               if(P[s] != T[j]) break;
21               else if(s = m-1)  { v = j ; return v ;}
22               else {++s;++j;}
23           }
24       
25       if(jm)
26           t[j+1] = (d*(t[j] -T[j+1]*h) +T[j+m])%q;
27   }
28 return -1;
29 
30 }

  具体参照http://net.pku.edu.cn/~course/cs101/2007/resource/Intro2Algorithm/book6/chap34.htm
 

  （4）BM算法

    BM算法可能是相对来说，算法效率最高的一种，一般是KMP算法的3~5倍。

    BM算法是从后缀比较法开始的。就是给出的算法（1）代码。然而，普通的后缀比较法一般移动只有1。而BM算法其实是对后缀蛮力匹配算法的改进。为了实现更快移动模式

串，BM算法定义了两个规则，好后缀规则和坏字符规则。用好后缀和坏字符可以大大加快模式串的移动距离，不是简单的 j，而是j =max (shift(好后缀), shift(坏字符))。

   

具体算法，如下图（网上百度别人博客中的图）：

      1、坏字符算法（情况分为两种）：

       

• 坏字符没出现在模式串中，这时可以把模式串移动到坏字符的下一个字符，继续比较，如下图：

• 坏字符出现在模式串中，这时可以把模式串第一个出现的坏字符和母串的坏字符对齐，当然，这样可能造成模式串倒退移动，如下图：

 

为了用代码来描述上述的两种情况，设计一个数组bmBc['k']，表示坏字符‘k’在模式串中出现的位置距离模式串末尾的最大长度，那么当遇到坏字符的时候，模式串可以移动距离为： shift(坏字符) = bmBc[T[i]]-（m-1-i)。如下图：

 

    2、好后缀算法（分为三种情况）

      

        

• 模式串中有子串匹配上好后缀，此时移动模式串，让该子串和好后缀对齐即可，如果超过一个子串匹配上好后缀，则选择最靠左边的子串对齐。

• 模式串中没有子串匹配上后后缀，此时需要寻找模式串的一个最长前缀，并让该前缀等于好后缀的后缀，寻找到该前缀后，让该前缀和好后缀对齐即可。

• 模式串中没有子串匹配上后后缀，并且在模式串中找不到最长前缀，让该前缀等于好后缀的后缀。此时，直接移动模式到好后缀的下一个字符。

为了实现好后缀规则，需要定义一个数组suffix[]，其中suffix[i] = s 表示以i为边界，与模式串后缀匹配的最大长度，如下图所示，用公式可以描述：满足P[i-s, i] == P[m-s, m]的最大长度s。

  

 

  好后缀算法比较难理解，理论解释是：

 

  好后缀数组（其中Suffx数组n内数字主要表示好后缀的最右边下标与最左边之间的差值）  

 

   i.  如果在P中位置t处已匹配部分P'在P中的某位置t'也出现，且位置t'的前一个字符与位置t的前一个字符不相同，则将P右移使t'对应t方才的所在的位置。

  ii.  如果在P中任何位置已匹配部分P'都没有再出现，则找到与P'的后缀P''相同的P的最长前缀x，向右移动P，使x对应方才P''后缀所在的位置。

    关于好后缀算法：

  

 1  int *Suff = new int[SubLen];
 2   Suff[SubLen-1] = SubLen;                                   //Suff数组主要记录以数组内标号为子串中的距离
 3 
 4   int *Suff2 = new int[SubLen];                              //Suff2数组主要记录下标为以i为首字母的字符后缀离最近的匹配字符串的距离
 5   for(int i=0;i)
 6   Suff2[i] = 0;                                              //初始化为0
 7 
 8   
 9  for(int i=SubLen-2;i>=0;i--)
10   {
11     int k=i;
12     while(k>=0 && SubString[k] == SubString[SubLen-1-i+k])   //下标SubLen+k-1-i与k相对应(从后面两个数进行比较,从而确定好后缀)
13     {
14         k--;                                                 
15     }
16     Suff[i] = i-k;                                           //其中i-k为最右边下标,数组中的下标为i，i代表子串中与最好后缀匹配的位置
17     if(Suff[i] != 0)
18         Suff2[m-Suff[i]] = SubLen-1-i;                       //确定偏移量
19   }
20 
21  int *bmGs = new int[SubLen];                                //bmGs数组主要记录当在i处（i处为坏字符），则需要移动的距离
22  for(int i=0;i1;++i)
23      bmGs[i] = SubLen;
24  bmGs[m-1] = 0;
25 
26  for(int i=SubLen-2;i >= 0;i--) 
27  {
28       if(Suff[m-1-Suff2[i+1]] !=0 && Suff[m-1-Suff2[i+1]]!=11)
29            
30           bmGs[i] = Suff2[i+1];                                                                 //移动距离S,当与好后缀匹配时,移动距离
31     
32       else 
33         {  
34 
35             for(int j=i+2;j)
36                 if(Suff[m-1-Suff2[j]] == (m-j))                                                 //判断与前缀是否匹配
37                 {    
38                     bmGs[i] = Suff2[j];                                                         //测算出偏移距离
39                     break;
40                 }
41            
42           
43          }
44  } 

     bmGs数组主要记录当在i处（i处为坏字符），则需要移动的距离；Suff2数组，下标表示i处出现坏字符时，在字符串前部最靠近坏字符且与i以后好后缀匹配的字符串的具体位

移量。从而可以测算出具体前部匹配具体坐标。

     下面给出具体BM算法：

   

  1 //坏字符算法，主要用来在移动时找到最大位移S,坏字符即移动最大距离
  2 void BM_ErrorChar(int SubLen,int CharByte[256],const char *SubString)
  3 {
  4    //BM_ErrorChar(SubLen,ByteChar);
  5    for(int i=0; i//SubLen-1,不考虑最后一个数
  6       CharByte[SubString[i]] = SubLen-i;      //如果i最后一个为SubLen-1，则最后一个距离根据计算，需要-1
  7 
  8 }
  9 
 10 
 11 int BM(const char *Source,const char *SubString)                      //Source为主串，SubString为子串
 12 { 
 13   int SourceLen = strlen(Source);
 14   int SubLen = strlen(SubString);
 15   int m=SubLen;
 16   //坏字符数组 （其中ByteChar数组的下标为字符，表示此字符出现最后一次离子串尾最近的距离）
 17   int ByteChar[256];                        //256是因为下标为字符，字符为ASCII码，8位，总共有256种组合
 18   for(int i=0;i<256;++i)
 19       ByteChar[i] = SubLen;
 20 
 21   
 22   //int *bmBc = new int[SubLen];
 23   //for(int i=1;i 24 
 25 
 26   //好后缀数组（其中Suff数组n内数字主要表示好后缀的最右边下标与最左边之间的差值）
 27   //   i.  如果在P中位置t处已匹配部分P'在P中的某位置t'也出现，且位置t'的前一个字符与位置t的前一个字符不相同，则将P右移使t'对应t方才的所在的位置。 
 28 
 29   //  ii.  如果在P中任何位置已匹配部分P'都没有再出现，则找到与P'的后缀P''相同的P的最长前缀x，向右移动P，使x对应方才P''后缀所在的位置。
 30 
 31   
 32   
 33   int *Suff = new int[SubLen];
 34   Suff[SubLen-1] = SubLen;                                   //Suff数组主要记录以数组内标号为子串中的距离
 35 
 36   int *Suff2 = new int[SubLen];                              //Suff2数组主要记录下标为以i为首字母的字符后缀离最近的匹配字符串的距离
 37   for(int i=0;i)
 38   Suff2[i] = 0;                                              //初始化为0
 39 
 40   
 41  for(int i=SubLen-2;i>=0;i--)
 42   {
 43     int k=i;
 44     while(k>=0 && SubString[k] == SubString[SubLen-1-i+k])   //下标SubLen+k-1-i与k相对应(从后面两个数进行比较,从而确定好后缀)
 45     {
 46         k--;                                                 
 47     }
 48     Suff[i] = i-k;                                           //其中i-k为最右边下标,数组中的下标为i，i代表子串中与最好后缀匹配的位置
 49     if(Suff[i] != 0)
 50         Suff2[m-Suff[i]] = SubLen-1-i;                       //确定偏移量
 51   }
 52 
 53  int *bmGs = new int[SubLen];                                //bmGs数组主要记录当在i处（i处为坏字符），则需要移动的距离
 54  for(int i=0;i1;++i)
 55      bmGs[i] = SubLen;
 56  bmGs[m-1] = 0;
 57 
 58  for(int i=SubLen-2;i >= 0;i--) 
 59  {
 60       if(Suff[m-1-Suff2[i+1]] !=0 && Suff[m-1-Suff2[i+1]]!=11)
 61            
 62           bmGs[i] = Suff2[i+1];                                                                 //移动距离S,当与好后缀匹配时,移动距离
 63     
 64       else 
 65         {  
 66 
 67             for(int j=i+2;j)
 68                 if(Suff[m-1-Suff2[j]] == (m-j))                                                 //判断与前缀是否匹配
 69                 {    
 70                     bmGs[i] = Suff2[j];                                                         //测算出偏移距离
 71                     break;
 72                 }
 73            
 74           
 75          }
 76  } 
 77 
 78 
 79 //开始BM算法
 80   //基于后缀回溯比较法
 81   int pSubLen  ,pSourLen =  SubLen;                          
 82   if(SubLen==0)
 83       return -1;
 84   while(pSourLen<=SourceLen)                                               //主串是否到了尽头             
 85   { 
 86       pSubLen = SubLen;                                                    //初始化
 87       while(SubString[--pSubLen]==Source[--pSourLen])                      //进行匹配比较
 88     {
 89 
 90        if(pSourLen < 0)  return -1;                                         //如果pSour,以子串长度为一组的主串扫描结束
 91            
 92        if(pSubLen == 0) return  pSourLen;                                   //为0,匹配成功
 93 
 94     }
 95     BM_ErrorChar(pSubLen,ByteChar,SubString);                                           //计算字符偏移量
 96     int CharLen = ByteChar[Source[pSourLen]];                                           //进行坏字符算法计算CharLen;
 97     int SuffLength = bmGs[pSubLen] ;                                                    //进行最好后缀法计算出来的偏移长度
 98     int MaxLen = MAX(CharLen, SuffLength);                                              //最后后缀算法，分情况讨论
 99         pSourLen += (SubLen-pSubLen);
100         pSourLen += MaxLen>1 ? MaxLen:1 ;                                               //进行偏移,pSour值进行恢复与回溯,SubArry - pSub为以前减去的值补回
101     
102   }
103   
104   return -1;
105 
106 }

      测试结果：

       char *T ="cddcdepcdedefgbcde";     //T为主串
       char *S = "cdedefgbcde" ;              //S为子串

      在T[7]处开始匹配。

 引用请注明出处：http://www.cnblogs.com/Su-30MKK/archive/2012/09/17/2688122.html

 

 

      

 

 

  

 

   

　　

  

 

 

 

转载于:https://www.cnblogs.com/Su-30MKK/archive/2012/09/17/2688122.html