關於字符串匹配的算法（一）

本文介紹多種字符串匹配的算法

1，樸素的字符串匹配。

使用循環來檢查各個char是否相等，算法比較簡單：

1. int naive_string_match(string a,string b)
3. {
5.        const char* stringa = a.c_str();
7.        const char* stringb = b.c_str();
9.        int a_len = a.length();
11.        int b_len = b.length();
13.        if ( a_len< b_len)
15.        {
17.               return -1;
19.        }
21.        int i;
23.        int j;
25.        for (i=0;i<(a_len-b_len+1);i++)
27.        {
29.               for (j=0;j<b_len;j++)
31.               {
33.                      if (stringa[j+i]!=stringb[j])
35.                      {
37.                             break;
39.                      }
41.                      if (j == b_len-1)
43.                      {
45.                             return i;//match
47.                      }
49.               }
51.        }
53.        return -1;
55. }

 

2，KMP算法

通過預處理，計算出跳轉表，以提高字符串匹配的效率，代碼主要分爲預處理和匹配兩個部分，在預處理過程和匹配過程的算法非常類似

代碼如下：

 

1. int KMP(string a,string b)
3. {
5.        const char* stringa = a.c_str();
7.        const char* stringb = b.c_str();
9.        int a_len = a.length();
11.        int b_len = b.length();
13.  
15.        //preprocessing
17.     int* p = new int[b_len];
19.     p[0]=-1;//index 0 is not used
21.     int temp=-1;
23.     int ii=1;
25.     for (;ii<b_len;ii++)
27.     {
29.         while (temp>0 && stringb[temp+1] != stringb[ii])
31.         {
33.             temp = p[temp];
35.         }
37.         if (stringb[temp+1] == stringb[ii])
39.         {
41.                temp++;
43.         }
45.         p[ii] = temp;
47.     }
49.  
51.        //matching
53.        int j=-1;
55.     int i;
57.     for (i=0;i<a_len;i++)
59.     {
61.         while (j>0&&stringb[j+1]!=stringa[i])
63.         {
65.             j=p[j];
67.         }
69.         if (stringb[j+1] == stringa[i])
71.         {
73.                 j++;
75.         }
77.         if (j==(b_len-1))
79.         {
81.                      delete[] p;
83.             return (i-b_len+1);
85.         }
87.     }
89.     delete[] p;
91.        return -1;
93. }

 

3，尋找最大匹配

使用數組記錄匹配的長度，記錄下最大的匹配和匹配開始的位置，輸出結果。

算法的複雜度是O（n×m）

代碼如下：

1. int find_biggest_macth(string a,string b)
3. {
5.        const char* stringa = a.c_str();
7.        const char* stringb = b.c_str();
9.        int a_len = a.length();
11.        int b_len = b.length();
13.        int* matcharray = new int[a_len];
15.        memset(matcharray,0,sizeof(int)*a_len);
17.  
19.        int i;
21.        int j;
23.        int match_pos1=-1;
25.        int match_pos2=-1;
27.        int match_length=0;
29.        for (i=0;i<b_len;i++)
31.        {
33.       
35.               for (j=a_len-1;j>0;j--)
37.               {
39.                      if (stringa[j] == stringb[i])
41.                      {
43.                             matcharray[j] = 1 + matcharray[j-1];
45.                             if (match_length<matcharray[j])
47.                             {
49.                                    match_length=matcharray[j];
51.                                    match_pos2=i-match_length+1;
53.                                    match_pos1=j-match_length+1;
55.                             }
57.                      }
59.               }
61.               if (stringa[0] == stringb[i])
63.               {
65.                      matcharray[0] = 1;
67.                      if (match_length<1)
69.                      {
71.                             match_length=1;
73.                             match_pos2=i;
75.                             match_pos1=0;
77.                      }
79.               }
81.        }
83.  
85.        cout<<match_length<<" "<<match_pos1 <<" "<<match_pos2<<endl;
87.        return 0;
89. }

 

4，Boyer Moore算法：

boyer moore算法和kmp算法類似，需要經過預處理，得到跳轉表。不過計算跳轉表的過程比kmp算法簡單的多。

1. int boyer_moore(string a,string b)
3. {
5.  
7.        const char* stringa = a.c_str();
9.        const char* stringb = b.c_str();
11.        int a_len = a.length();
13.        int b_len = b.length();
15.       
17.        //preprocessing
19.        int skiptable[256];
21.        for (int h=0;h<b_len;h++)
23.        {
25.               int pos = stringb[h]-'a';
27.               skiptable[pos] = b_len-h;
29.        }
31.  
33.        //matching
35.        int i=0;
37.        while(i<a_len)
39.        {
41.               for (int j=b_len-1;j>=0;j--)
43.               {
45.                      if (stringa[i+j]!= stringb[j])
47.                      {
49.                             int pos = stringb[j] - 'a';
51.                             i += skiptable[pos];
53.                             break;
55.                      }
57.                      if (j==0)//find
59.                      {
61.                             return i;
63.                      }
65.               }
67.        }
69.        return -1;
71. }