此篇文章轉載自劉毅學長，部分內容按博主理解進行修改
一：背景
給定一個主串（以 S 代替）和模式串（以 P 代替），要求找出 P 在 S 中出現的位置，此即串的模式匹配問題。
Knuth-Morris-Pratt 算法（簡稱 KMP）是解決這一問題的常用算法之一，這個算法是由高德納（Donald Ervin Knuth）和沃恩·普拉特在 1974 年構思，同年詹姆斯·H·莫里斯也獨立地設計出該算法，最終三人於 1977 年聯合發表。
在繼續下面的內容之前，有必要在這里介紹下兩個概念：真前綴 和 真后綴。
由上圖所得， "真前綴"指除了自身以外，一個字符串的全部頭部組合；"真后綴"指除了自身以外，一個字符串的全部尾部組合。（網上很多博客，應該說是幾乎所有的博客，也包括我以前寫的，都是“前綴”。嚴格來說，“真前綴”和“前綴”是不同的，既然不同，還是不要混為一談的好！）
二：朴素字符串匹配算法
初遇串的模式匹配問題，我們腦海中的第一反應，就是朴素字符串匹配（即所謂的暴力匹配），代碼如下：
/* 字符串下標始於 0 */
int NaiveStringSearch(string S, string P)
{
int i = 0; // S 的下標
int j = 0; // P 的下標
int s_len = S.size();
int p_len = P.size();
while (i < s_len && j < p_len)
{
if (S[i] == P[j]) // 若相等，都前進一步
{
i++;
j++;
}
else // 不相等
{
i = i - j + 1;
j = 0;
}
}
if (j == p_len) // 匹配成功
return i - j;
return -1;
}
暴力匹配的時間復雜度為 \(O(nm)\)，其中 \(n\) 為 S 的長度，\(m\) 為 P 的長度。很明顯，這樣的時間復雜度很難滿足我們的需求。
接下來進入正題：時間復雜度為 \(Θ(n+m)\) 的 KMP 算法。
三：KMP字符串匹配算法
3.1 算法流程
以下摘自阮一峰的字符串匹配的KMP算法，並作稍微修改。
（1）
首先，主串"BBC ABCDAB ABCDABCDABDE"的第一個字符與模式串"ABCDABD"的第一個字符，進行比較。因為 B 與 A 不匹配，所以模式串后移一位。
（2）
因為 B 與 A 又不匹配，模式串再往后移。
（3）
就這樣，直到主串有一個字符，與模式串的第一個字符相同為止。
（4）
接着比較主串和模式串的下一個字符，還是相同。
（5）
直到主串有一個字符，與模式串對應的字符不相同為止。
（6）
這時，最自然的反應是，將模式串整個后移一位，再從頭逐個比較。這樣做雖然可行，但是效率很差，因為你要把"搜索位置"移到已經比較過的位置，重比一遍。
（7）
一個基本事實是，當空格與 D 不匹配時，你其實是已經知道前面六個字符是"ABCDAB"。KMP 算法的想法是，設法利用這個已知信息，不要把"搜索位置"移回已經比較過的位置，而是繼續把它向后移，這樣就提高了效率。
（8）
| i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| 模式串 | A | B | C | D | A | B | D | '\0' |
| next[i] | -1 | 0 | 0 | 0 | 0 | 1 | 2 | 0 |
怎么做到這一點呢？可以針對模式串，設置一個跳轉數組int next[]，這個數組是怎么計算出來的，后面再介紹，這里只要會用就可以了。
（9）
已知空格與 D 不匹配時，前面六個字符"ABCDAB"是匹配的。根據跳轉數組可知，不匹配處 D 的 next 值為 2，因此接下來從模式串下標為 2 的位置開始匹配。
（10）
因為空格與Ｃ不匹配，C 處的 next 值為 0，因此接下來模式串從下標為 0 處開始匹配。
（11）
因為空格與 A 不匹配，此處 next 值為 - 1，表示模式串的第一個字符就不匹配，那么直接往后移一位。
（12）
逐位比較，直到發現 C 與 D 不匹配。於是，下一步從下標為 2 的地方開始匹配。
（13）
逐位比較，直到模式串的最后一位，發現完全匹配，於是搜索完成。
3.2 next 數組是如何求出的
next 數組的求解基於“真前綴”和“真后綴”，即next[i]等於P[0]...P[i - 1]最長的相同真前后綴的長度（請暫時忽視 i 等於 0 時的情況，下面會有解釋）。我們依舊以上述的表格為例，為了方便閱讀，我復制在下方了。
| i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| 模式串 | A | B | C | D | A | B | D | '\0' |
| next[ i ] | -1 | 0 | 0 | 0 | 0 | 1 | 2 | 0 |
-
i = 0，對於模式串的首字符，我們統一為
next[0] = -1； -
i = 1，前面的字符串為
A，其最長相同真前后綴長度為 0，即next[1] = 0； -
i = 2，前面的字符串為
AB，其最長相同真前后綴長度為 0，即next[2] = 0； -
i = 3，前面的字符串為
ABC，其最長相同真前后綴長度為 0，即next[3] = 0； -
i = 4，前面的字符串為
ABCD，其最長相同真前后綴長度為 0，即next[4] = 0； -
i = 5，前面的字符串為
ABCDA，其最長相同真前后綴為A，即next[5] = 1； -
i = 6，前面的字符串為
ABCDAB，其最長相同真前后綴為AB，即next[6] = 2； -
i = 7，前面的字符串為
ABCDABD，其最長相同真前后綴長度為 0，即next[7] = 0。
那么，為什么根據最長相同真前后綴的長度就可以實現在不匹配情況下的跳轉呢？舉個代表性的例子：假如i = 6時不匹配，此時我們是知道其位置前的字符串為ABCDAB，仔細觀察這個字符串，首尾都有一個AB，既然在i = 6處的 D 不匹配，我們為何不直接把i = 2處的 C 拿過來繼續比較呢，因為都有一個AB啊，而這個AB就是ABCDAB的最長相同真前后綴，其長度 2 正好是跳轉的下標位置。
有的讀者可能存在疑問，若在i = 5時匹配失敗，按照我講解的思路，此時應該把i = 1處的字符拿過來繼續比較，但是這兩個位置的字符是一樣的啊，都是B，既然一樣，拿過來比較不就是無用功了么？其實不是我講解的有問題，也不是這個算法有問題，而是這個算法還未優化，關於這個問題在下面會詳細說明，不過建議讀者不要在這里糾結，跳過這個，下面你自然會恍然大悟。
思路如此簡單，接下來就是代碼實現了，如下：
/* P 為模式串，下標從 0 開始 */
void GetNext(string P, int next[])
{
int p_len = P.size();
int i = 0; // P 的下標
int j = -1;
next[0] = -1;
while (i < p_len)
{
if (j == -1 || P[i] == P[j])
{
i++;
j++;
next[i] = j;
}
else
j = next[j];
}
}
一臉懵逼，是不是。。。上述代碼就是用來求解模式串中每個位置的next[]值。
下面具體分析，我把代碼分為兩部分來講：
（1）：i 和 j 的作用是什么？
i 和 j 就像是兩個”指針“，一前一后，通過移動它們來找到最長的相同真前后綴。
（2）：if...else...語句里做了什么？
假設 i 和 j 的位置如上圖，由next[i] = j得，也就是對於位置 i 來說，區段 [0, i - 1] 的最長相同真前后綴分別是 [0, j - 1] 和 [i - j, i - 1]，即這兩區段內容相同。
按照算法流程，if (P[i] == P[j])，則i++; j++; next[i] = j;；若不等，則j = next[j]，見下圖：
next[j]代表 [0, j - 1] 區段中最長相同真前后綴的長度。如圖，用左側兩個橢圓來表示這個最長相同真前后綴，即這兩個橢圓代表的區段內容相同；同理，右側也有相同的兩個橢圓。所以 else 語句就是利用第一個橢圓和第四個橢圓內容相同來加快得到 [0, i - 1] 區段的相同真前后綴的長度。
細心的朋友會問 if 語句中j == -1存在的意義是何？第一，程序剛運行時，j 是被初始為 -1，直接進行P[i] == P[j]判斷無疑會邊界溢出；第二，else 語句中j = next[j]，j 是不斷后退的，若 j 在后退中被賦值為 -1（也就是j = next[0]），在P[i] == P[j]判斷也會邊界溢出。綜上兩點，其意義就是為了特殊邊界判斷。
四：完整代碼
#include <iostream>
#include <string>
using namespace std;
/* P 為模式串，下標從 0 開始 */
void GetNext(string P, int next[])
{
int p_len = P.size();
int i = 0; // P 的下標
int j = -1;
next[0] = -1;
while (i < p_len)
{
if (j == -1 || P[i] == P[j])
{
i++;
j++;
next[i] = j;
}
else
j = next[j];
}
}
/* 在 S 中找到 P 第一次出現的位置 */
int KMP(string S, string P, int next[])
{
GetNext(P, next);
int i = 0; // S 的下標
int j = 0; // P 的下標
int s_len = S.size();
int p_len = P.size();
while (i < s_len && j < p_len) // 因為末尾 '\0' 的存在，所以不會越界
{
if (j == -1 || S[i] == P[j]) // P 的第一個字符不匹配或 S[i] == P[j]
{
i++;
j++;
}
else
j = next[j]; // 當前字符匹配失敗，進行跳轉
}
if (j == p_len) // 匹配成功
return i - j;
return -1;
}
int main()
{
int next[100] = { 0 };
cout << KMP("bbc abcdab abcdabcdabde", "abcdabd", next) << endl; // 15
return 0;
}
五：KMP優化
| i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| 模式串 | A | B | C | D | A | B | D | '\0' |
| next[i] | -1 | 0 | 0 | 0 | 0 | 1 | 2 | 0 |
以 3.2 的表格為例（已復制在上方），若在i = 5時匹配失敗，按照 3.2 的代碼，此時應該把i = 1處的字符拿過來繼續比較，但是這兩個位置的字符是一樣的，都是B，既然一樣，拿過來比較不就是無用功了么？這我在 3.2 已經解釋過，之所以會這樣是因為 KMP 還未優化。那怎么改寫就可以解決這個問題呢？很簡單。
/* P 為模式串，下標從 0 開始 */
void GetNextval(string P, int nextval[])
{
int p_len = P.size();
int i = 0; // P 的下標
int j = -1;
nextval[0] = -1;
while (i < p_len)
{
if (j == -1 || P[i] == P[j])
{
i++;
j++;
if (P[i] != P[j])
nextval[i] = j;
else
nextval[i] = nextval[j]; // 既然相同就繼續往前找真前綴
}
else
j = nextval[j];
}
}
六：參考文獻
- 嚴蔚敏. 數據結構（C 語言版）
- 阮一峰. 字符串匹配的KMP算法