【輪子已造好】來了，字符串匹配算法
Live each day like it could be your last.
把天天都看成生命的最後一天，認真生活。
引言
大道至簡，個人理想是用最簡單的代碼實現最美的算法。字符串匹配的應用很是普遍，java的indexOf(),js的全家桶一套匹配(find，indexOf,include...)等等。本文主要分享了它們底層依賴的字符串匹配算法。兩種簡單，兩種複雜。話很少說，全部源碼均已上傳至github:連接java
ps：BF算法是字符串匹配算法裏最簡單的了，須要作到知其然並知其因此然。RK算法理解是BF + HASH。至於後面的BM和KMP，能作到看懂理解其原理就行，前輩們已經造好了輪子，在須要的時候能想到用便可，尬寫出來有很多難度。
BF算法
bf算法俗稱樸素匹配算法，爲何叫這個名字呢，由於很暴力，在主串中，檢查起始位置分別是 0、一、2…n-m 且長度爲 m 的 n-m+1 個子串，看有沒有跟模式串匹配的。git
解析
在這裏i循環是跟蹤主串txt,j是跟蹤模式串pattern，首先外圍先肯定訪問次數，tLen-pLen。github
j循環來進行比較，這裏可能惟一比較很差理解的是i + j，查看測試結果，應該能夠明白。算法
private int bfSearch(String txt, String pattern) {
int tLen = txt.length();
int pLen = pattern.length();
if (tLen < pLen) return -1;
for (int i = 0; i <= tLen - pLen; i++) {
int j = 0;
for (; j < pLen; j++) {
System.out.println(txt.charAt(i + j) + " -- " + pattern.charAt(j));
if (txt.charAt(i + j) != pattern.charAt(j)) break;
}
if (j == pLen) return i;
}
return -1;
}複製代碼
變體
bf算法還有一個變化，用到了顯示回退的思想，i，j的做用和常規的同樣，這裏的i至關於常規的i+j,只不過當發現不匹配的時候，須要回退i和j這兩個指針，j從新回到開頭，i指向下一個字符。數組
private int bfSearchT(String txt, String pattern) {
int tLen = txt.length();
int i = 0;
int pLen = pattern.length();
int j = 0;
for (; i < tLen && j < pLen; i++) {
System.out.println(txt.charAt(i) + " -- " + pattern.charAt(j));
if (txt.charAt(i) == pattern.charAt(j)) {
++j;
} else {
i -= j;
j = 0;
}
}
if (j == pLen) {
System.out.println("end... i = " + i + ",plen = " + pLen);
return i - pLen;
}
return -1;
}複製代碼
測試代碼
ps： hello worldbash
public static void main(String[] args) {
BFArithmetic bf = new BFArithmetic();
String txt = "hello world";
String pattern = "world";
int res = bf.bfSearch(txt, pattern);
System.out.println("BF算法匹配結果:" + res);
// int resT = bf.bfSearchT(txt, pattern);
// System.out.println("BF算法(顯示回退)匹配結果:" + resT);
}複製代碼
測試結果
RK算法
rk算法至關於bf算法的進階版，它主要是引入了哈希算法。下降了時間複雜度。經過哈希算法對主串中的 n-m+1 個子串分別求哈希值，而後逐個與模式串的哈希值比較大小。若是某個子串的哈希值與模式串相等，那就說明對應的子串和模式串匹配了。由於哈希值是一個數字，數字之間比較是否相等是很是快速的，因此模式串和子串比較的效率就提升了。dom
初始化
這裏要把模式串預製進去，生成相對應的hash值，而後隨機生成一個大素數，便於後續的使用。函數
private RKArithmetic(String pattern) {
this.pattern = pattern;
pLen = pattern.length();
aLen = 256;
slat = longRandomPrime();
System.out.println("隨機素數：" + slat);
aps = 1;
// aLen^(pLen - 1) % slat
for (int i = 1; i <= pLen - 1; i++) {
aps = (aLen * aps) % slat;
}
patHash = hash(pattern, pLen);
System.out.println("patHash = " + patHash);
}複製代碼
準備
隨機生成一個大素數測試
private static long longRandomPrime() {
BigInteger prime = BigInteger.probablePrime(31, new Random());
return prime.longValue();
}複製代碼
哈希算法ui
private long hash(String txt, int i) {
long h = 0;
for (int j = 0; j < i; j++) {
h = (aLen * h + txt.charAt(j)) % slat;
}
return h;
}複製代碼
校驗字符串是否匹配
private boolean check(String txt, int i) {
for (int j = 0; j < pLen; j++)
if (pattern.charAt(j) != txt.charAt(i + j))
return false;
return true;
}複製代碼
實現
該實現仍是比較容易閱讀的，只不過將比較換成了hash值的比較。
private int rkSearch(String txt) {
int n = txt.length();
if (n < pLen) return -1;
long txtHash = hash(txt, pLen);
if ((patHash == txtHash) && check(txt, 0))
return 0;
for (int i = pLen; i < n; i++) {
txtHash = (txtHash + slat - aps * txt.charAt(i - pLen) % slat) % slat;
txtHash = (txtHash * aLen + txt.charAt(i)) % slat;
int offset = i - pLen + 1;
System.out.println("第" + offset + "次txtHash = " + txtHash);
if ((patHash == txtHash) && check(txt, offset))
return offset;
}
return -1;
}複製代碼
測試代碼
public static void main(String[] args) {
String pat = "world";
String txt = "hello world";
RKArithmetic searcher = new RKArithmetic(pat);
int res = searcher.rkSearch(txt);
System.out.println("RK算法匹配結果：" + res);
}複製代碼
測試結果
BM算法
BM算法的輪子已經造好。聽說是最高效，最經常使用的字符串匹配算法。
分析
- 核心思想：是經過將模式串沿着主串大踏步的向後滑動，從而大大減小比較次數，下降時間複雜度。而算法的關鍵在於如何兼顧步子邁得足夠大與無遺漏，同時要儘可能提升執行效率。這就須要模式串在向後滑動時，遵照壞字符規則與好後綴規則，同時採用一些技巧。
- 壞字符規則：從後往前逐位比較模式串與主串的字符，當找到不匹配的壞字符時，記錄模式串的下標值si，並找到壞字符在模式串中，位於下標si前的最近位置xi（若無則記爲-1），si-xi即爲向後滑動距離。（PS：我以爲加上xi必須在si前面，也就是比si小的條件，就不用擔憂計算出的距離爲負了）。可是壞字符規則向後滑動的步幅還不夠大，因而須要好後綴規則。
- 好後綴規則：從後往前逐位比較模式串與主串的字符，當出現壞字符時中止。若存在已匹配成功的子串｛u｝，那麼在模式串的｛u｝前面找到最近的｛u｝，記做｛u'｝。再將模式串後移，使得模式串的｛u'｝與主串的｛u｝重疊。若不存在｛u'｝，則直接把模式串移到主串的｛u｝後面。爲了沒有遺漏，須要找到最長的、可以跟模式串的前綴子串匹配的，好後綴的後綴子串（同時也是模式串的後綴子串）。而後把模式串向右移到其左邊界，與這個好後綴的後綴子串在主串中的左邊界對齊。
準備
構建壞字符哈希表
private void generateBC(char[] patChars, int[] records) {
for (int i = 0; i < aLen; i++) {
records[i] = -1;
}
for (int i = 0; i < patChars.length; i++) {
// 計算 b[i] 的 ASCII 值
int ascii = (int) patChars[i];
records[ascii] = i;
}
System.out.println("壞字符哈希表：");
print(records);
}複製代碼
好後綴
private void generateGS(char[] patChars, int[] suffix, boolean[] prefix) {
int pLen = patChars.length;
for (int i = 0; i < pLen; ++i) { // 初始化
suffix[i] = -1;
prefix[i] = false;
}
for (int i = 0; i < pLen - 1; ++i) {
int j = i;
// 公共後綴子串長度
int k = 0;
while (j >= 0 && patChars[j] == patChars[pLen - 1 - k]) {
--j;
++k;
//j+1 表示公共後綴子串在 patChars[0, i] 中的起始下標
suffix[k] = j + 1;
}
// 若是公共後綴子串也是模式串的前綴子串
if (j == -1) prefix[k] = true;
}
}複製代碼
移動
private int moveByGS(int index, int pLen, int[] suffix, boolean[] prefix) {
int k = pLen - 1 - index; // 好後綴長度
if (suffix[k] != -1) return index - suffix[k] + 1;
for (int i = index + 2; i <= pLen - 1; i++) {
if (prefix[pLen - i])
return i;
}
return -1;
}複製代碼
實現
- suffix 在模式串中，查找跟好後綴匹配的另外一個子串
- prefix 記錄模式串的後綴子串是否能匹配模式串的前綴子串
private int bmSearch(String txt, String pattern) {
// 記錄模式串中每一個字符最後出現的位置
int[] records = new int[aLen];
char[] txtChars = txt.toCharArray();
int tLen = txtChars.length;
char[] patChars = pattern.toCharArray();
int pLen = patChars.length;
generateBC(patChars, records);
int[] suffix = new int[pLen];
boolean[] prefix = new boolean[pLen];
generateGS(patChars, suffix, prefix);
//主串與模式串對齊的第一個字符
int index = 0;
while (index <= tLen - pLen) {
int i = pLen - 1;
// 模式串從後往前匹配
for (; i >= 0; --i) {
// 壞字符對應模式串中的下標是 i
if (txtChars[index + i] != patChars[i]) break;
}
if (i < 0) {
return index;
}
int x = i - records[(int) txtChars[index + i]];
int y = 0;
if (i < pLen - 1) {
y = moveByGS(i, pLen, suffix, prefix);
}
System.out.println("x = " + x + ",y = " + y);
index = index + Math.max(x, y);
}
return -1;
}複製代碼
測試代碼
public static void main(String[] args) {
BMArithmetic bmArithmetic = new BMArithmetic();
String txt = "hello world";
String pattern = "world";
int res = bmArithmetic.bmSearch(txt, pattern);
System.out.println("BM算法匹配結果：" + res);
}
複製代碼
測試結果
BM啓發式算法（精簡版）
分析
BM算法不愧是號稱線性級得計算，聽說效率是KMP算法的3~4倍，有時間必定要驗一下。
ps：遇到問題若是正着思考行不通，不妨反着考慮，新思想，get√。
初始化
private BoyerMoore(String pattern) {
this.pattern = pattern;
pLen = pattern.length();
int aLen = 256;
records = new int[aLen];
//初始化記錄數組，默認-1
for (int i = 0; i < aLen; i++) {
records[i] = -1;
}
//模式串中的字符在其中出現的最右位置
for (int j = 0; j < pLen; j++) {
records[pattern.charAt(j)] = j;
}
}複製代碼
實現
根據命名skip也能分析出倆關鍵字倒序，跳躍性。
private int bmSearch(String txt) {
int tLen = txt.length();
int skip;
for (int i = 0; i <= tLen - pLen; i += skip) {
skip = 0;
for (int j = pLen - 1; j >= 0; --j) {
System.out.println(txt.charAt(i + j) + " -- " + pattern.charAt(j));
if (txt.charAt(i + j) != pattern.charAt(j)) {
skip = j - records[txt.charAt(i + j)];
if (skip < 1) skip = 1;
break;
}
}
if (skip == 0) return i;
}
return -1;
}複製代碼
測試代碼
public static void main(String[] args) {
String txt = "hello world";
String pattern = "world";
BoyerMoore bm = new BoyerMoore(pattern);
int res = bm.bmSearch(txt);
System.out.println("BM算法匹配結果：" + res);
}複製代碼
測試結果
KMP算法
分析
kmp算法引入一個失效函數--next數組。這個算法的關鍵就在於next函數是如何計算出來的。妙趣橫生？不，是頭皮發麻，難以理解。只能debug一步一步跟了。
準備
精髓：理解k = next[k]。由於前一個的最長串的下一個字符不與最後一個相等，須要找前一個的次長串，問題就變成了求0到next(k)的最長串，若是下個字符與最後一個不等，繼續求次長串，也就是下一個next(k)，直到找到，或者徹底沒有。
private int[] getNext(char[] patChars, int pLen) {
int[] next = new int[pLen];
next[0] = -1;
int k = -1;
for (int i = 1; i < pLen; i++) {
while (k != -1 && patChars[k + 1] != patChars[i]) {
k = next[k];
}
if (patChars[k + 1] == patChars[i])
++k;
next[i] = k;
}
System.out.println("好前綴：");
print(next);
return next;
}複製代碼
實現
private int kmpSearch(String txt, String pattern) {
char[] txtChars = txt.toCharArray();
int tLen = txtChars.length;
char[] patChars = pattern.toCharArray();
int pLen = patChars.length;
int[] next = getNext(patChars, pLen);
int index = 0;
for (int i = 0; i < tLen; i++) {
while (index > 0 && txtChars[i] != patChars[index]) {
index = next[index - 1] + 1;
}
System.out.println(txtChars[i] + " -- " + patChars[index]);
if (txtChars[i] == patChars[index])
++index;
if (index == pLen)
return i - pLen + 1;
}
return -1;
}複製代碼
測試代碼
public static void main(String[] args) {
KMPArithmetic kmpArithmetic = new KMPArithmetic();
String txt = "hello world";
String pattern = "world";
int res = kmpArithmetic.kmpSearch(txt, pattern);
System.out.println("KMP算法匹配結果：" + res);
}複製代碼
測試結果
KMP算法（基於肯定優先狀態自動機dfa）
初始化
private KMPByDFA(String pattern) {
this.pattern = pattern;
this.pLen = pattern.length();
int aLen = 256;
dfa = new int[aLen][pLen];
dfa[pattern.charAt(0)][0] = 1;
int i = 0;
for (int j = 1; j < pLen; j++) {
for (int k = 0; k < aLen; k++) {
//複製匹配失敗狀況下的值
dfa[k][j] = dfa[k][i];
}
//設置匹配成功狀況下的值
dfa[pattern.charAt(j)][j] = j + 1;
//更新從新狀態
i = dfa[pattern.charAt(j)][i];
}
}複製代碼
實現
private int kmpSearch(String txt) {
int i = 0;
int j = 0;
int tLen = txt.length();
for (; i < tLen && j < pLen; i++) {
j = dfa[txt.charAt(i)][j];
}
//找到匹配，到達模式串的結尾
if (j == pLen)
return i - pLen;
return -1;
}複製代碼
測試代碼
public static void main(String[] args) {
String txt = "hello world";
String pattern = "world";
KMPByDFA kmp = new KMPByDFA(pattern);
int res = kmp.kmpSearch(txt);
System.out.println("BM算法匹配結果：" + res);
}複製代碼
測試結果
end
您的點贊和關注是對我最大的支持，謝謝！
相關文章
- 1. 字符串匹配算法
- 2. 字符串匹配算法——KMP算法
- 3. 算法 - KMP算法(字符串匹配)
- 4. KMP 算法 —— 字符串匹配算法
- 5. 算法之「字符串匹配算法」
- 6. 字符串匹配算法--BM算法
- 7. 透徹理解KMP算法 - 字符串匹配/子串查找
- 8. 【數據結構】 字符串&KMP子串匹配算法
- 9. LeetCode 字符串相乘（造輪子）
- 10. [造輪子] 分割字符串
- 更多相關文章...
- • R 字符串 - R 語言教程
- • Swift 字符串 - Swift 教程
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
- • 算法總結-廣度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 字符串匹配算法
- 2. 字符串匹配算法——KMP算法
- 3. 算法 - KMP算法(字符串匹配)
- 4. KMP 算法 —— 字符串匹配算法
- 5. 算法之「字符串匹配算法」
- 6. 字符串匹配算法--BM算法
- 7. 透徹理解KMP算法 - 字符串匹配/子串查找
- 8. 【數據結構】 字符串&KMP子串匹配算法
- 9. LeetCode 字符串相乘（造輪子）
- 10. [造輪子] 分割字符串