《算法》筆記 15 - 子字符串查找
- 暴力子字符串查找算法
- 隱式回退
- 性能
- 顯式回退
- Knuth-Morris-Pratt算法
- 肯定有限狀態自動機
- DFA的構造
- 性能
- Boyer-Moore算法
- 跳躍表的構建
- 性能
- Rabin-Karp指紋字符串算法
- 關鍵思想
- Horner方法
- 性能
字符串的一種基本操做就是子字符串查找。好比在文本編輯器或是瀏覽器中查找某個單詞時，就是在查找子字符串。子字符串的長度（可能爲100或1000）相對於整個文本的長度（可能爲100萬甚至是10億）來講通常是很短的，在如此多的字符中找到匹配的模式是一個很大的挑戰，爲此計算機科學家們發明了多種有趣、經典且高效的算法。c++
暴力子字符串查找算法
要解決這個問題，首先想到的是暴力查找的方法，在文本中模式可能出現匹配的任何地方檢查是否匹配。算法
隱式回退
首先是隱式回退的實現方式，之因此叫隱式回退，在與顯式回退的實現對比後就明白緣由了。數組
public static int search(String pat, String txt) {
int patL = pat.length();
int txtL = txt.length();
for (int i = 0; i <= txtL - patL; i++) {
int j;
for (j = 0; j < patL; j++)
if (txt.charAt(i + j) != pat.charAt(j))
break;
if (j == patL)
return i;
}
return txtL;
}
用一個索引i跟蹤文本，另外一個索引j跟蹤模式。對於每一個i，代碼首先將j重置爲0，並不斷把它加1，直到找到了一個不匹配的字符，或者j增長到patL，此時就找到了匹配的子字符串。瀏覽器
性能
在通常狀況下，索引j增加的機會不多，絕大多數時候在比較第一個字符是就會產生不匹配。
在長度爲N的文本中，查找長度爲M的子字符串時：dom
- 在最好狀況下，對於每一個i，在索引j=0時就發現了不匹配，一共須要進行N次字符比較；
- 在最壞的狀況下，對於前N-1個i，索引j都須要增長到M-1次，纔會發現不匹配，最後一次匹配，好比文本和模式都是一連串的A接一個B。這種狀況下，對於N-M+1個可能的匹配位置，都須要M次比較，一共須要進行M*(N-M+1)次比較，由於N遠大於M，因此忽略小數值後結果爲~NM。
顯式回退
public static int search1(String pat, String txt) {
int j, patL = pat.length();
int i, txtL = txt.length();
for (i = 0, j = 0; i <= txtL && j < patL; i++) {
if (txt.charAt(i) == pat.charAt(j))
j++;
else {
i -= j;
j = 0;
}
}
if (j == patL)
return i - patL;
else
return txtL;
}
與隱式回退同樣，也使用了索引i和j分別跟蹤文本和模式的字符，但這裏的i指向的是匹配過的字符序列的末端，因此這裏的i至關與隱式回退中的i+j，若是字符不匹配，就須要回退i和j的位置，將j回退爲0，指向模式的開頭，將i指向本次匹配的開始位置的下一個字符。
隱式回退的實現方式中，匹配位置的的末端字符是經過i+j指定的，因此只須要將j從新設爲0，就實現了文本和模式字符的回退。編輯器
Knuth-Morris-Pratt算法
暴力算法在每次出現不匹配時，都會回退到本次匹配開始位置的下一個字符，但其實在不匹配時，就能知道一部分文本的內容，所以能夠利用這些信息減小回退的幅度，Knuth-Morris-Pratt算法（簡稱KMP算法）就是基於這種思想。
好比，假設文本只有A和B構成，那麼在查找模式字符串爲B A A A A A A A時，若是在匹配到第6個字符時出現不匹配，此時能夠肯定文本中的前6個字符就是B A A A A B，接下來不須要回退i，只需將i+1, j+2後，繼續和模式的第二個字符匹配便可，由於模式的第一個字符是B，而上一次匹配失敗的末尾字符也是B。
而對於文本A A B A A B A和模式A A B A A A，在文本的第6個字符處發現不匹配後，應該從第4個字符開始從新匹配，這樣就不會錯過已經匹配的部分了。
KMP算法的主要思想就是提早判斷如何從新開始查找，而這種判斷只取決於模式自己。函數
肯定有限狀態自動機
KMP算法中不會回退文本索引i，而是使用一個二維數組dfa來記錄匹配失敗時模式索引j應該回退多遠。對於每一個字符c，在比較了c和pat.charAt(j)以後，dfa[c][i]表示的是應該和下個文本字符比較的模式字符的位置。
這個過程其實是對肯定有限狀態自動機（DFA）的模擬，dfa數組定義的正是一個肯定有限狀態自動機。DFA由狀態（數字標記的圓圈）和轉換（帶標籤的箭頭）組成，模式中的每一個字符都對應着一個狀態，用模式字符串的索引值表示。
【DFA】圖和數組
在標記爲j的狀態中檢查文本中的第i個字符時，自動機會沿着轉換dfa[txt.charAt(i)][j]前進並繼續將i+1，對於一個匹配的轉換，就向右移動一位，對於一個不匹配的智慧，就根據自動機的指示回退j。自動機從狀態0開始，若是到達了最終的中止狀態M，則查找成功。性能
DFA的構造
DFA是KMP算法的核心，構造給定模式對應的DFA也是這個算法的關鍵問題。DFA指示了應該如何處理下一個字符。若是在pat.charAt(j)處匹配成功，DFA應該前進到狀態j+1。但若是匹配失敗，DFA會從已經構造過的模式中獲取到須要的信息，以模式 A B A B A C的構造過程舉例：
下面表格表示dfa[][]，橫向表頭表示模式字符，括號中是當前的狀態。學習
1.初始狀態，各位置都是0：
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|0|0|0|0|0|0|
B|0|0|0|0|0|0|
C|0|0|0|0|0|0|
2.先看字符匹配成功時的狀況，這時對應的狀態會指向下一個狀態：
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|0|3|0|5|0|
B|0|2|0|4|0|0|
C|0|0|0|0|0|6|this
3.在狀態0，匹配失敗時，不管是B仍是C都退到初始狀態，從新開始；
4.在狀態1，匹配失敗時，若是此時的字符爲A，則文本爲A A，能夠跳過狀態0，直接到狀態1，與A(0)行爲一致，因此將A(0)的值複製到B(1)，在DFA中對應的值也爲1；而對於字符C，文本爲A C，只能退回到狀態0,從新開始
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|1|||||
B|0|2|||||
C|0|0|||||
5.在狀態2，匹配失敗時，若是此時的字符爲B，則文本爲A B B，回到狀態0；若是是字符C，文本爲A B C，也只能退回到狀態0。
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|1|3||||
B|0|2|0||||
C|0|0|0||||
6.在狀態3，匹配失敗時，若是此時的字符爲A，則文本爲A B A A，直接到狀態1；若是是字符C，文本爲A B A C，回到狀態0
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|1|3|1|||
B|0|2|0|4|||
C|0|0|0|0|||
7.在狀態4，匹配失敗時，若是此時的字符爲B，則文本爲A B A B B，回到狀態0；若是是字符C，文本爲A B A B C，回到狀態0
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|1|3|1|5||
B|0|2|0|4|0||
C|0|0|0|0|0||
8.在狀態5，匹配失敗時，若是此時的字符爲a，則文本爲A B A B A A，回到狀態1；若是是字符B，文本爲A B A B A B，回到狀態4，由於前面的A B A B都是匹配的，能夠跳過。
-|A(0)|B(1)|A(2)|B(3)|A(4)|C(5)
-:|:-:|:-:|:-:|:-:|:-:|:-:
A|1|1|3|1|5|1|
B|0|2|0|4|0|4|
C|0|0|0|0|0|6|
經過以上過程可知，在計算狀態爲j的DFA時，總能從尚不完整、已經計算完成的j-1個狀態中獲得所需的信息。
dfa[pat.charAt(0)][0] = 1;
for (int X = 0, j = 1; j < M; j++) {
for (int c = 0; c < R; c++)
dfa[c][j] = dfa[c][X];
dfa[pat.charAt(j)][j] = j + 1;
X = dfa[pat.charAt(j)][X];
}
代碼中，用X維護了每次重啓時的狀態，而後具體的作法是：
- 匹配失敗時，將dfa[][X]複製到dfa[][j]；
- 匹配成功時，將dfa[pat.chatAt(j)][j]的值設爲j+1；
- 將X更新爲dfa[pat.charAt(j)][X]
初始化完成dfa後，查找的代碼爲：
public int search(String txt) {
int i, j, N = txt.length(), M = pat.length();
for (i = 0, j = 0; i < N && j < M; i++) {
j = dfa[txt.charAt(i)][j];
}
if (j == M)
return i - M;
else
return N;
}
性能
在長度爲N的文本中，查找長度爲M的子字符串時，KMP算法會先初始化dfa，訪問模式字符串中的每一個字符一次，查找時在最壞狀況下，會把文本中的字符都訪問一次，因此KMP算法訪問的字符最多爲N+M個。
KMP算法爲最壞狀況提供線性級別運行時間的保證。雖然在實際應用中，KMP算法相比暴力算法的速度優點並不明顯，由於現實狀況下的文本和模式通常不會有很高的重複性。
但KMP算法還有一個很是重要的優勢，就是它不須要在輸入中回退，這使得KMP算法很是適合在長度不肯定的輸入流中進行查找，而那些須要回退的算法在處理這種輸入時卻須要複雜的緩衝機制。
Boyer-Moore算法
KMP算法不須要在輸入中回退，但接下來學習的Boyer-Moore算法卻利用回退得到了巨大的性能收益。
Boyer-Moore算法是從右向左掃描模式字符串的，好比在查找模式字符串B A A B B A A時，若是匹配了第七、第6個字符，而後在第5個字符處匹配失敗，那麼就能夠知道文本中對應的第5 6 7個字符分別是X A A，而X必然不是B，接下來就能夠直接跳到第14個字符了。但並非每次都能前進這麼大的幅度，由於模式的結尾部分也可能出如今文本的其餘位置，因此和KMP算法同樣，這個算法也須要一個記錄重啓位置的數組。
跳躍表的構建
有了記錄重啓位置的數組，就能夠在匹配失敗時，知道應該向右跳躍多遠了，使用一個right數組記錄字母表中的每一個字符在模式中出現的最靠右的地方，若是字符在模式中不存在，則表示爲-1。right數組又稱爲跳躍表。
構建跳躍表時，先將全部元素設爲-1，而後對於0到M-1的j，將right[pat.chatAt(j)]設爲j。
public BoyerMoore(String pat) {
this.pat = pat;
int M = pat.length();
int R = 256;
right = new int[R];
for (int c = 0; c < R; c++)
right[c] = -1;
for (int j = 0; j < M; j++)
right[pat.charAt(j)] = j;
}
模式 N E E D L E對應的跳躍表爲
A B C D E ... L M N -1 -1 -1 3 5 -1 4 -1 0
算法會使用一個索引i在文本從左向右移動，用索引j在模式中從右向左移動，而後不斷檢查txt.charAt(i+j)和pat.charAt(j)是否匹配，若是對於模式中的全部字符都匹配，則查找成功；若是匹配失敗，分三種狀況處理：
- 若是形成匹配失敗的字符不在模式中，則將模式字符串向右移動j+1個位置，小於這個偏移量都會使模式字符串覆蓋的區域中再次包含該字符；
. . . T L E . . .
N E E D L E
^ ^
i j
. . . T L E . . .
N E E D L E
^ ^
i增大j+1 j重置爲M-1
- 若是字符在模式中，則根據跳躍表，使該字符和它在模式字符串中對應最右的位置對齊，小於這個偏移量也會使該字符與模式中其它字符重疊；
. . . N L E . . .
N E E D L E
^ ^
i j
. . . N L E . . .
N E E D L E
^
i增大j-right['N']
- 若是根據跳躍表得出的結果，沒法使模式字符串向右移動，則將i+1，保證至少向右移動了一個位置。
. . . . . E L E . . .
N E E D L E
^ ^
i j
. . . . . E L E . . .
N E E D L E
這種狀況會使模式字符串向右移動，只能將i+1
. . . . . E L E . . .
N E E D L E
^
i=i+1
查找算法的實現爲：
public int search(String txt) {
int N = txt.length();
int M = pat.length();
int skip;
for (int i = 0; i <= N - M; i += skip) {
skip = 0;
for (int j = M - 1; j >= 0; j--) {
if (pat.charAt(j) != txt.charAt(i + j)) {
skip = j - right[txt.charAt(i + j)];
if (skip < 1)
skip = 1;
break;
}
}
if(skip==0) return i;
}
return N;
}
性能
最好狀況下，每次跳躍的距離都是M，那麼最終只須要N/M次比較。
在最壞的狀況下，跳躍失效，等同於暴力算法，好比在一連串A A A A A ...中查找B A A ...，這時須要M*N次比較。
在實際應用場景中，模式字符串中僅含有字符集中的少許字符是很常見的，所以幾乎全部的比較都會使算法跳過M個字符，因此通常來講算法須要~N/M次比較。
Rabin-Karp指紋字符串算法
M.O.Rabin和R.A.Karp發明的基於散列的字符串查找算法，與前面兩種算法的思路徹底不一樣。計算模式字符串的散列值，而後使用相同的散列函數，計算文本逐位計算M個字符的散列值，若是得出的散列值與模式字符串的散列值相同，就再繼續逐字符驗證一次，確保匹配成功。
但若是直接按照這種方式，得出的算法效率減比暴力算法還要低不少，而Rabin和Karp發明了一種可以在常數時間內算出M個字符的子字符串散列值的方法，這使得這種算法的運行時間下降到了線性級別。
關鍵思想
散列函數通常使用除留餘數法，除數選擇一個儘可能大的素數。算法的關鍵在於只要知道上一個位置M個字符的散列值，就可以快速得算出下一個位置M個字符的散列值。以數字字符串來舉例：
2 6 5 3 5 %997=613
5 9 2 6 5 3 5
5 9 2 6 5 %997=442
9 2 6 5 3 %997=929
2 6 5 3 5 %997=613(匹配)
在上面的過程當中，模式字符串26535能夠看做一個十進制的數字，它要匹配的每M個字符也均可以看做是一個M爲的整數，59265用997取餘後的結果爲442，接下來92653取餘時不須要重頭計算
59265=5*10000+9265 92653=9265+3*1 因此 92653=(59265-5*10000)*10+3*1
而對於普通的字符串，若是它的字符集中有R個字符，則能夠把這些字符串看做是R進制的數字，用ti表示txt.charAt(i)，則：
xi=tiRM-1+ti+1RM-2+...+ti+M-1R0
與得出92653的過程同樣，將模式字符串右移一位即等價於將xi替換爲：
xi+1=(xi-tiRM-1)R+ti+M
Horner方法
計算散列值時，若是是int值，能夠直接取餘，但對於一個至關於R進制的數字的字符串，要得出它的餘數，就須要用Horner方法，Horner方法的理論依據是，若是在每次算術操做以後都將結果除Q取餘，這等價於在完成了全部算術操做以後再將最後的結果除Q取餘：
private long hash(String key, int M) {
long h = 0;
for (int j = 0; j < M; j++)
h = (R * h + key.charAt(j)) % Q;
return h;
}
對於一個R進制的數字，從左至右，將它的每一位數字的散列值乘以R，加上這個數字，並計算除Q的餘數。
那麼隨着索引i的增長，逐位計算M個字符的散列值時，就能夠利用跟Horner方法相同的原理了：
public class RabinKarp {
private String pat;
private long patHash;
private int M;
private long Q;
private int R = 256;
private long RM;
public RabinKarp(String pat) {
this.pat = pat;
M = pat.length();
Q = longRandomPrime();
RM = 1;
for (int i = 1; i <= M - 1; i++)
RM = (R * RM) % Q;
patHash = hash(pat, M);
}
private boolean check(String txt, int i) {
for (int j = 0; j < M; j++)
if (pat.charAt(j) != txt.charAt(i + j))
return false;
return true;
}
private long hash(String key, int M) {
long h = 0;
for (int j = 0; j < M; j++)
h = (R * h + key.charAt(j)) % Q;
return h;
}
// a random 31-bit prime
private static long longRandomPrime() {
BigInteger prime = BigInteger.probablePrime(31, new Random());
return prime.longValue();
}
public int search(String txt) {
int N = txt.length();
long txtHash = hash(txt, M);
if (patHash == txtHash && check(txt, 0))
return 0;
for (int i = M; i < N; i++) {
txtHash = (txtHash + Q - RM * txt.charAt(i - M) % Q) % Q;
txtHash = (txtHash * R + txt.charAt(i)) % Q;
if (patHash == txtHash)
if (check(txt, i - M + 1))
return i - M + 1;
}
return N;
}
}
性能
取餘所選的Q值是一個很大的素數，這裏使用的是使用BigInteger.probablePrime生成的一個31位素數，其大小與231接近，那麼在將模式字符串的散列值與文本中M個字符的散列值比較時，產生衝突的機率約爲2-31，這是一個極小的值，因此算法中的check方法能夠省略掉，Rabin-Karp算法的性能爲線性級別，
- 1. 字符串：查找子字符串
- 2. 子字符串查找
- 3. 字符串類——KMP子串查找算法
- 4. 查找已知字符串子串
- 5. Sunday算法（字符串查找、匹配）
- 6. 透徹理解KMP算法 - 字符串匹配/子串查找
- 7. KMP字符串查找算法
- 8. 字符串查找算法及原理
- 9. KMP子串查找算法
- 10. 連續重複子字符串查找
- 更多相關文章...
- • Lua 字符串 - Lua 教程
- • Swift 字符串 - Swift 教程
- • 算法總結-二分查找法
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 字符串：查找子字符串
- 2. 子字符串查找
- 3. 字符串類——KMP子串查找算法
- 4. 查找已知字符串子串
- 5. Sunday算法（字符串查找、匹配）
- 6. 透徹理解KMP算法 - 字符串匹配/子串查找
- 7. KMP字符串查找算法
- 8. 字符串查找算法及原理
- 9. KMP子串查找算法
- 10. 連續重複子字符串查找