大話數據結構（五）字符匹配算法C++實現（樸素、KMP等）
1 樸素的模式匹配算法
1.1 原理
串的模式匹配：子串的定位操作。
- 算法思想
假設從主串S = “goodgoogle”中找T = “google”這個子串的位置。要按以下步驟：（豎線表示相同，折線表示不同）
![在這裏插入圖片描述]()
簡單地說，就是對主串的每一個字符作爲子串開頭，與要匹配的字符串進行匹配。此過程中，對主串做大循環，每個字符開頭做T的長度的小循環，直到匹配成功或全部遍歷完成爲止。假設主串S和匹配的子串T的長度存在S[0]與T[0]中，該算法實現如下：
/* 返回子串T在主串S中第pos個字符之後的位置。若不存在,則函數返回值爲0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用於主串S中當前位置下標值，若pos不爲1，則從pos位置開始匹配 */
int j = 1; /* j用於子串T中當前位置下標值 */
while (i <= S[0] && j <= T[0]) /* 若i小於S的長度並且j小於T的長度時，循環繼續 */
{
if (S[i] == T[j]) /* 兩字母相等則繼續 */
{
++i;
++j;
}
else /* 指針後退重新開始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
該算法中最關鍵的步驟是回退過程：
- 兩字母相等時，在小循環內繼續循環比較。
- 兩字母不等時，則回退。對於i，回退的位置是i = i - j +2。對於j，回退到1，重新從開始比較待匹配串。
有讀者可能不理解i的回退位置如何計算的，且看以下圖示，假設pos = 3。
圖中，①開始進入while循環，因爲n ≠ d，進入else回退。此時應該從i的下一位 d 再開始比較，i - j 回退到o位置，再加 2 則恰好進到 d 位置；j = 1，即j位置不變。如圖②。
②中因爲d = d，進入小循環，i、j不斷累加（while ->if -> while -> if -> while …），直到圖③，f ≠ r，再回退，此時應該從開始進入小循環的i的下一位 e 再開始比較，i - j 回退到n位置，再加 2 則恰好進到 e 位置；j = 1，即j回到最初位置。如圖④。以同樣方式，再繼續循環比較，不再贅述。
綜上，i - j +2就是主串長度減去已匹配的子串長度，再加2，則進位到下一個要匹配的主串位置。（加1就是進入小循環的位置）
1.2 時間複雜度
樸素模式匹配算法時間複雜度分析如下：（n爲主串長度，m爲模式串長度）
| 情況 | 時間複雜度 | 備註 |
|---|---|---|
| 最好情況 | 一開始就匹配成功 | |
| 最壞情況 | 每次不成功的匹配都發生在模式串的最後一個字符 | |
| 平均情況 | 根據等概率原則，平均是(n+m)/2次查找 |
1.3 c++代碼實現
此處實現模板串從第一個位置與主串比較，且i，j代表字符串的索引值（類似數組），故與上面算法實現相差1位。
此處串的第一位不存儲長度，改由length函數獲取，故i的回溯求法爲i-j+1；
//在主串s中找子串t，若找到返回字串在主串中的索引；若沒找到返回-1
#include <iostream>
#include <string>
using namespace std;
//輸入串s，模板串t，返回匹配成功時，在串s的索引
int index(string s, string t)
{
int s_len = s.length(); //計算串s、t的長度
int t_len = t.length();
int i = 0; //i爲主串索引
int j = 0; //j爲模板串索引
while ( i < s_len && j < t_len )//如果i、j都各自小於lens和lent
{
if (s[i] == t[j]) // 如果子串的t[j]和主串的s[i]相等
{
++i; //各自索引都自增
++j;
}
else //否則，主串的索引比剛開始後移一個；子串的索引變爲0 兩個索引都回溯
{
i = i - j + 1;
j = 0;
}
}
if (j == t_len) //如果j和lent的大小一樣，證明找到了，返回子串在主串中的索引
{
return i - t_len;
}
else // 否則返回 - 1
{
return -1;
}
}
int main()
{
string s = "goodgoogle";
string t = "google";
int pos = index(s, t);
if (pos != -1)
{
cout << "find index: " << pos << " of " << s << endl;
}
else
{
cout << "not find!" << endl;
}
system("pause");
return 0;
}
運行結果：
2 KMP模式匹配算法
2.1 原理，參考：https://www.bilibili.com/video/BV1jb411V78H?from=search&seid=14906988811959903401
- 算法關鍵
如果主串S= “abcdefgab”，子串T= “abcdex”，用上面的樸素算法的話，前5個字母，兩串完全相等，直到第6個字母，“f”與“x”不等，如下圖。接下來進行②③④⑤⑥的步驟，而T中“a”與後邊的每一位都不同，對於①中，前5位已經相同，所以，T中“a”也不會與S中的第2-5位相同，則②③④⑤的判斷是多餘的。只用保留①⑥，之所以保留⑥，是因爲在①中T[6]≠S[6]，儘管我們已經知道T[1]≠T[6]，但也不能斷定T[1]一定不等於S[6]，因此需要保留⑥。
![在這裏插入圖片描述]()
假設主串S= “abcabcabc”，子串T= “abcabx”，前5個相對，第6個不等。根據剛剛的經驗，T的首字符“a”與第二位“b”、第三位“c”均不相等，所以不需要做判斷，下圖中②③是多餘的。又因爲T的首位與第四位相等，T的第二位與第五位相等，而在①中，子串中第四位的“a”與第五位的“b”已經與主串S中相應的位置比較過了，是相等的，因此可以斷定，T的首字符“a”、第二位的“b”與S的第四、第五位字符也不需要比較了，肯定也是相等的——之前比較過了，不需要再次判斷，所以④⑤這兩個步驟也可以省略。（即T前部=T後部，T後部=S後部，則T前部=S後部）
![在這裏插入圖片描述]()
對比發現，i的值從6-2-3-4-5-6，即在樸素的模式匹配算法中，主串的i值是不斷地回溯來完成的，而我們分析發現，這種回溯過程是可以不需要的。KMP算法就是爲了讓沒必要的回溯不發生。既然i不回溯（不會變小），我們就要考慮j值的變化了。對比上面兩圖，我們發現，j的變化與T串的首字符和自身後面字符是否相等有關，而與主串無關，即j值的變化關鍵取決於T串的結構中是否有重複的問題。如一圖中，T=“abcdex”，當中沒有任何重複字符，所以j由6變爲1，二圖中，T=“abcabx”，前綴“ab”與最後“x”前的“ab”相等，因此j就由6變成了3。因此可以得出規律，j值的多少取決於當前字符之間的串的前後綴的相似度。我們把T串各位置的j值的變化定義爲一個數組next，那麼next的長度就是T串的長度，則有如下函數定義：
![在這裏插入圖片描述]()
- ①當j=1，next[1]爲0;
- ②噹噹前子串匹配位置的前面存在最大公共子串，則next爲最大公共子串長度+1；
- ③當其他情況，next爲0
2.2 next數組值推導
看兩個例子。（取自書中）
2.3 KMP模式匹配算法實現
/* 通過計算返回子串T的next數組。 */
void get_next(String T, int *next)
{
int i,j;
i=1;
j=0;
next[1]=0;
while (i<T[0]) /* 此處T[0]表示串T的長度 */
{
if(j==0 || T[i]== T[j]) /* T[i]表示後綴的單個字符，T[j]表示前綴的單個字符 */
{
++i;
++j;
next[i] = j;
}
else
j= next[j]; /* 若字符不相同，則j值回溯 */
}
}
這段代碼的目的就是爲了計算出當前要匹配的串T的next數組。
/* 返回子串T在主串S中第pos個字符之後的位置。若不存在，則函數返回值爲0。 */
/* T非空，1≤pos≤StrLength(S)。 */
int Index_KMP(String S, String T, int pos)
{
int i = pos; /* i用於主串S中當前位置下標值，若pos不爲1，則從pos位置開始匹配 */
int j = 1; /* j用於子串T中當前位置下標值 */
int next[255]; /* 定義一next數組 */
get_next(T, next); /* 對串T作分析，得到next數組 */
while (i <= S[0] && j <= T[0]) /* 若i小於S的長度並且j小於T的長度時，循環繼續 */
{
if (j==0 || S[i] == T[j]) /* 兩字母相等則繼續，與樸素算法增加了j=0判斷 */
{
++i;
++j;
}
else /* 指針後退重新開始匹配 */
j = next[j];/* j退回合適的位置，i值不變 */
}
if (j > T[0])
return i-T[0];
else
return 0;
}
2.4 KMP的時間複雜度
3中相對於樸素匹配算法增加的代碼，主要去掉了i的回溯部分。首先分析KMP的核心算法流程，假設現在文本串S匹配到 i 位置，模式串T匹配到 j 位置：
- 如果當前字符匹配成功（即S[i] == T[j]），則令++i，++j，繼續匹配下一個字符；
- 如果當前字符匹配失敗（即S[i] != T[j]），則令 i 不變，j = next[j]。意味着匹配失配時，模式串T相對於文本串S向右移動了j - next [j] 位。
正如前文，若主串S= “abcabcabc”，子串T= “abcabx”，由T得next[j] = [0,1,1,1,2,3]，因爲S[6]（這裏下標i、j從1開始）≠T[6]，所以，j=next[6]=3，T相當於移動了6-3=3個位置。如圖：
對於get_next函數而言，若T的長度爲m，因只涉及簡單的單循環，其時間複雜度爲O（m），而由於i不回溯，使得index_KMP算法效率得到了提高，while循環的時間複雜度爲O（n），以上兩個函數先後線性執行，因此，整個算法的時間複雜度爲O（n+m）。相較於樸素模式匹配算法的O（（n-m+1）*m）來說，是要好一些。需要說明的是，KMP算法僅當模式與主串之間存在許多“部分匹配”的情況下才體現出它的優勢，否則和樸素模式匹配算法相比，差異並不明顯。
3 KMP模式匹配算法改進
後來有人發現，KMP還是有缺陷的。比如，如果我們的主串S = “aaaabcde”，子串T = “aaaaax”，其next數組值分別爲012345，在開始時，當i=5、j=5時，我們發現“b”與“a”不相等，如下圖①，因此j=next[5]=4，如圖②，此時“b”與第4位置的“a”依然不等，j=next[4]=3，如圖③，後依次是④⑤，直到j=next[1]=0時，根據算法，此時i++、j++，得到i=6、j=1，如圖⑥。
我們發現，當中的②③④⑤其實是多餘的，由於T的第二、三、四、五位的字符與首位“a”相等，那麼可以用首位next[1]的值去取代與它相等的字符後續next[]的值，這是個很好的辦法，對next數組進行優化。假設取代的數組爲nextval，增加了部分，如下：
/* 求模式串T的next函數修正值並存入數組nextval */
void get_nextval(String T, int *nextval)
{
int i,j;
i=1;
j=0;
nextval[1]=0;
while (i<T[0]) /* 此處T[0]表示串T的長度 */
{
if(j==0 || T[i]== T[j]) /* T[i]表示後綴的單個字符，T[j]表示前綴的單個字符 */
{
++i;
++j;
if (T[i]!=T[j]) /* 若當前字符與前綴字符不同 */
nextval[i] = j; /* 則當前的j爲nextval在i位置的值 */
else
nextval[i] = nextval[j]; /* 如果與前綴字符相同，則將前綴字符的 */
/* nextval值賦值給nextval在i位置的值 */
}
else
j= nextval[j]; /* 若字符不相同，則j值回溯 */
}
}
nextval數組值推導
改良後，nextval值就與next值不完全相同了，如下例子：
總結改進過的KMP算法，它是在計算出next值的同時，如果a位字符與它next值指向的b位字符相等，則該a位的nextval 就指向b位的nextval值，如果不等，則該a位的nextval值就是它自己a位的next的值。