串的模式匹配算法之kmp

---

title: 串的模式匹配算法之kmp

tags: 數據結構與算法之美

author: 辰砂

---

1.引言

首先我們需要了解串的模式算法目的：確定主串中所含子串第一次出現的位置（定位）；常見的算法種類： BF算法（又稱古典的、經典的、朴素的、窮舉的），KMP算法（特點：速度快）。網上有很多帖子，博客寫的都特別好，這篇文章也是對自己的一個總結。

2.BF算法

BF算法設計思想：

---

將主串的第pos個字符和模式的第一個字符比較
若相等，繼續逐個比較后續字符；
若不等，從主串的下一字符起，重新與模式的第一個字符比較。
直到主串的一個連續子串字符序列與模式相等 。
返回值為S中與T匹配的子序列第一個字符的序號，即匹配成功。
否則，匹配失敗，返回值 0

---

1.舉例：

假設現在我們面臨這樣一個問題：有一個文本串S，和一個模式串P，現在要查找P在S中的位置，怎么查找呢？

 

如果用暴力匹配的思路，並假設現在文本串S匹配到 i 位置，模式串P匹配到 j 位置，則有：

如果當前字符匹配成功（即S[i] == P[j]），則i++，j++，繼續匹配下一個字符；

如果失配（即S[i]! = P[j]），令i = i - (j - 1) （表示主串的位置回到當前的下一個位置），j = 0。相當於每次匹配失敗時，i 回溯，j 被置為0。

1. public static int bfMatch(char[] s, char[] p) {
   int sLen = s.length;
   int pLen = p.length;
   int i = 0;
   int j = 0;
   while (i < sLen && j < pLen) {
   if (s[i] == p[j]) {
   //①如果當前字符匹配成功（即S[i] == P[j]），則i++，j++
   i++;
   j++;
   } else {
   //②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0
   // i - (j - 1) 表示主串的位置回到當前的下一個位置。
   i = i - j + 1;
   j = 0;
   }
   }
   //匹配成功，返回模式串p在文本串s中的位置，否則返回-1
   if (j == pLen) {
   return i - j;
   } else {
   return -1;
   }
   }
   public static void main(String[] args) {
   String s = "BBC ABCDAB ABCDABCDABDE";
   String p = "ABCDABD";
   System.out.println(bfMatch(s.toCharArray(),p.toCharArray()));
   }

    

2.時間復雜度說明：

若n為主串長度，m為子串長度，最壞情況是 主串前面n-m個位置都部分匹配到子串的最后一位，即這n-m位各比較了m次 最后m位也各比較了1次

總次數為：(n-m)m+m＝(n-m+1)m 若m<<n，則算法復雜度o(n*m)< p="">

網上有個很好的例子，故引用：

舉個例子，如果給定文本串S“BBC ABCDAB ABCDABCDABDE”，和模式串P“ABCDABD”，現在要拿模式串P去跟文本串S匹配，整個過程如下所示：

1.S[0]為B，P[0]為A，不匹配，執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[1]跟P[0]匹配，相當於模式串要往右移動一位（i=1，j=0）

2.S[1]跟P[0]還是不匹配，繼續執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[2]跟P[0]匹配（i=2，j=0），從而模式串不斷的向右移動一位（不斷的執行“令i = i - (j - 1)，j = 0”，i從2變到4，j一直為0）

3.直到S[4]跟P[0]匹配成功（i=4，j=0），此時按照上面的暴力匹配算法的思路，轉而執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，可得S[i]為S[5]，P[j]為P[1]，即接下來S[5]跟P[1]匹配（i=5，j=1）

4.S[5]跟P[1]匹配成功，繼續執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此進行下去

5.直到S[10]為空格字符，P[6]為字符D（i=10，j=6），因為不匹配，重新執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，相當於S[5]跟P[0]匹配（i=5，j=0）

6.至此，我們可以看到，如果按照暴力匹配算法的思路，盡管之前文本串和模式串已經分別匹配到了S[9]、P[5]，但因為S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，從而讓S[5]跟P[0]匹配。

而S[5]肯定跟P[0]失配。為什么呢？因為在之前第4步匹配中，我們已經得知S[5] = P[1] = B，而P[0] = A，即P[1] != P[0]，故S[5]必定不等於P[0]，所以回溯過去必然會導致失配。那有沒有一種算法，讓i 不往回退，只需要移動j 即可呢？

3.KMP算法（主串指針不回溯）

算法思想：利用已經部分匹配的結果而加快模式串的滑動速度？且主串S的指針i不必回溯！可提速到O(n+m)！

算法步驟： 下面先直接給出KMP的算法流程：

---

假設現在文本串S匹配到 i 位置，模式串P匹配到 j 位置

 

如果j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++，繼續匹配下一個字符；

 

如果j != -1，且當前字符匹配失敗（即S[i] != P[j]），則令 i 不變，j = next[j]。此舉意味着失配時，模式串P相對於文本串S向右移動了j - next [j] 位。

 

換言之，當匹配失敗時，模式串向右移動的位數為：失配字符所在位置 - 失配字符對應的next 值（next 數組的求解會在下文的3.3.3節中詳細闡述），即移動的實際位數為：j - next[j]，且此值大於等於1。

 

---

很快，你也會意識到next 數組各值的含義：代表當前字符之前的字符串中，有多大長度的相同前綴后綴。例如如果next [j] = k，代表j 之前的字符串中有最大長度為k 的相同前綴后綴。

此也意味着在某個字符失配時，該字符對應的next 值會告訴你下一步匹配中，模式串應該跳到哪個位置（跳到next [j] 的位置）。如果next [j] 等於0或-1，則跳到模式串的開頭字符，若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某個字符，而不是跳到開頭，且具體跳過了k 個字符。

public static int kmpMatch(char[] s, char[] p) {
int sLen = s.length;
int pLen = p.length;
int i = 0;
int j = 0;
while (i < sLen && j < pLen) {
if (s[i] == p[j]) {
//①如果當前字符匹配成功（即S[i] == P[j]），則i++，j++
i++;
j++;
} else {
j = next[j];
}
}
//匹配成功，返回模式串p在文本串s中的位置，否則返回-1
if (j == pLen) {
return i - j;
} else {
return -1;
}
}

 

為此,定義next[j]函數，表明當模式中第j個字符與主串中相應字符“失配”時，在模式中需重新和主串中該字符進行比較的字符的位置。

1.如何求next()?

1.尋找前綴后綴最長公共元素長度

比如 字符串 ‘a’ 的前綴就是為空，后綴也是為空，所以前綴后綴的意思，是不包括當前字符串，字符串 ‘ab’ 的前綴是a，后綴是b。

定義： 對於P = p0 p1 ...pj-1 pj，尋找模式串P中長度最大且相等的前綴和后綴。如果存在p0 p1 ...pk-1 pk = pj- k pj-k+1...pj-1 pj，那么在包含pj的模式串中有最大長度為k+1的相同前綴后綴。

比如：

j	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
模式串	a	b	c	a	a	b	c	a	b	c	a	a	a	b	d	a	b
前后綴最長公共元素	0	0	0	1	1	2	3	1	2	3	4	5	6	2	0	1	2

 

 

 

2.求next數組

next 數組考慮的是除當前字符外的最長相同前綴后綴，所以通過第①步驟求得各個前綴后綴的公共元素的最大長度后，只要稍作變形即可：將第①步驟中求得的值整體右移一位，然后初值賦為-1，如下表格所示：

j	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
模式串	a	b	c	a	a	b	c	a	b	c	a	a	a	b	d	a	b
next[j]	0	1	1	1	2	2	3	1	1	2	3	4	5	6	2	1	2

 

 

 

 

 

 

3.如何求next函數值

1. next[1] = 0;表明主串從下一字符si+1起和模式串重新開始匹配。i = i+1; j = 1;

    

2. 設next[j] = k，則next[j+1] = ?

    

   ①若pk=pj，則有“p1…pk-1pk”=“pj-k+1…pj-1pj” ，如果在 j+1發生不匹配，說明next[j+1] = k+1 = next[j]+1。

    

   ②若pk≠pj，可把求next值問題看成是一個模式匹配問 題，整個模式串既是主串，又是子串。

    

   

若pk’=pj，則有“p1…pk’”=“pj-k’+1…pj”， next[j+1]=k’+1=next[k]+1=next[next[j]]+1.

若pk”=pj ，則有“p1…pk””=“pj-k”+1…pj”， next[j+1]=k”+1=next[k’]+1=next[next[k]]+1. next[j+1]=1.

 

 

4.總結

核心的點在於：以前的bf算法是需要i進行回溯，導致時間復雜度O(m*n) ,現在kmp算法的核心是i不進行回溯，而j這個值不確定，根據串的規律，主串前面匹配成功的串前綴和后綴相等的地方不需要匹配即可。這樣的時間復雜度是O(m + n)

引用博客例子：

1.最開始匹配時

P[0]跟S[0]匹配失敗

 

所以執行“如果j != -1，且當前字符匹配失敗（即S[i] != P[j]），則令 i 不變，j = next[j]”，所以j = -1，故轉而執行“如果j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++”，得到i = 1，j = 0，即P[0]繼續跟S[1]匹配。

 

P[0]跟S[1]又失配，j再次等於-1，i、j繼續自增，從而P[0]跟S[2]匹配。

 

P[0]跟S[2]失配后，P[0]又跟S[3]匹配。

 

P[0]跟S[3]再失配，直到P[0]跟S[4]匹配成功，開始執行此條指令的后半段：“如果j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++”。

 

 

2.P[1]跟S[5]匹配成功，P[2]跟S[6]也匹配成功, ...，直到當匹配到P[6]處的字符D時失配（即S[10] != P[6]），由於P[6]處的D對應的next 值為2，所以下一步用P[2]處的字符C繼續跟S[10]匹配，相當於向右移動：j - next[j] = 6 - 2 =4 位。

3.向右移動4位后，P[2]處的C再次失配，由於C對應的next值為0，所以下一步用P[0]處的字符繼續跟S[10]匹配，相當於向右移動：j - next[j] = 2 - 0 = 2 位。

4.移動兩位之后，A 跟空格不匹配，模式串后移1 位。

5.P[6]處的D再次失配，因為P[6]對應的next值為2，故下一步用P[2]繼續跟文本串匹配，相當於模式串向右移動 j - next[j] = 6 - 2 = 4 位。

6.匹配成功，過程結束。

匹配過程一模一樣。也從側面佐證了，next 數組確實是只要將各個最大前綴后綴的公共元素的長度值右移一位，且把初值賦為-1 即可。

代碼如下：

void get_next(SString T, int &next[])
{
i= 1; next[1] = 0; j = 0;
while( i<T[0]){
if(j==0 || T[i] == T[j]){
++i; ++j;
next[i] = j;
}
else
j = next[j];
}
}

 

kMP算法的時間復雜度

設主串s的長度為n,模式串t長度為m,在KMP算法中求next數組的時間復雜度為O(m),在后面的匹配中因主串s的下標不減即不回溯,比較次數可記為n,所以KMP算法總的時間復雜度為O(n+m)

---

參考原文：https://blog.csdn.net/vjulyv/article/details/7041827?utm_source=copy