indexOf實現引伸出來的各類字符串匹配算法
咱們在表單驗證時，常常遇到字符串的包含問題，好比說郵件必須包含indexOf。咱們如今說一下indexOf。這是es3.1引進的API ，與lastIndexOf是一套的。能夠用於字符串與數組中。一些面試常常用問數組的indexOf是如何實現的，但鮮有問如何實現字符串的indexOf是如何實現，由於這是很難很難。要知道，咱們平時業務都是與字符串與數組打交道，像數字與日期則更加專業（涉及到二進制，曆法）是經過庫來處理。javascript
咱們回來想一下爲何字符串的indexOf爲什麼如此難？這涉及到前綴與後綴的問題，或更專業的說，你應該想到前綴樹或後綴樹。若是你連這些概念都沒有，你是寫很差indexOf。字符串的問題，能夠簡單理解爲遍歷，分爲所有遍歷或跳着查找。html
咱們看最簡單的Brute-Force算法（又被戲稱爲boyfirend算法）。有兩個字符串，長的稱之爲目標串，短的通常叫模式串。前端
其算法思想是從目標串的第一個字符串與模式串的第一字符串比較，若是相等，移動目標串的索引，將模式串的索引歸零，讓目標串的子串與模式串繼續逐字比較。java
Brute-Force算法
function indexOf(longStr, shortStr, pos) {
var i = pos || 0
/*------------------------------------*/
//若串S中從第pos(S的下標0<= pos <=StrLength(S))個字符起存在和串T相同的子串，則匹配成功。
//返回第一個這樣的子串在串S中的下標；不然返回-1
var j = 0;
while (true) {
if (longStr[i + j] == void 0)
break
if (longStr[i + j] === shortStr[j]) {
j++; //繼續比較後一個字符
if (shortStr[j] === void 0) {
return i
}
} else {
//從新開始新一輪的匹配
i++;
j = 0;
}
}
return -1; //串S中(第pos個字符起)不存在和串T相同的子串
}
console.log(indexOf('aadddaa', 'ddd'))
KMP算法
第二個是大名鼎鼎的「看毛片」算法，由Knuth，Morris，Pratt三人分別獨立研究出來，其對於任何模式和目標序列，均可以在線性時間內完成匹配查找，而不會發生退化，是一個很是優秀的模式匹配算法。它的核心思想是預處理模式串，將模式串構造一個跳轉表，有兩種形式的跳轉表，next與nextval, nextval能夠基於next構建，也能夠不。面試
下面這篇文章詳KMP 的工件原理，你們有興趣看看算法
http://blog.csdn.net/qq_29501587/article/details/52075200數組
但如何構建next,nextval呢？我搜了許多文章終於找到相關介紹，我彙總在下面的算法中了。編輯器
function getNext(str) {
// 求出每一個子串的先後綴的共有長度，而後所有總體後移一位，首項爲定值-1，獲得next數組：
//首先能夠確定的是第一位的next值爲0，第二位的next值爲1，後面求解每一位的next值時，
//根據前一位的next值對應的字符與當前字符比較，相同，在前一位的next值加1，
//不然直接讓它與第一個字符比較，求得共有長度
//好比說ababcabc
var next = [0] //第一個子串只有一個字母，不用比較，沒有公共部分，爲0
for (var i = 1, n = str.length; i < n; i++) {
var c = str[i]
var index = next[i - 1]
if (str[index] === c) { // a, a
next[i] = index + 1
} else {
next[i] = str[0] === c ? 1 : 0 //第一次比較a, b
}
}
// [0, 0, 1, 2, 0, 1, 2, 0]
next.unshift(-1)
next.pop();
// -1, 0 , 0, 1,2 ,0,1,2
return next
}
function getNextVal(str) {
//http://blog.csdn.net/liuhuanjun222/article/details/48091547
var next = getNext(str)
//咱們令 nextval[0] = -1。從 nextval[1] 開始，若是某位(字符)與它 next 值指向的位(字符)相同，
//則該位的 nextval 值就是指向位的 nextval 值(nextval[i] = nextval[ next[i] ])；
//若是不一樣，則該位的 nextval 值就是它本身的 next 值(nextvalue[i] = next[i])。
var nextval = [-1]
for (var i = 0, n = str.length; i < n; i++) {
if (str[i] === str[next[i]]) {
nextval[i] = nextval[next[i]]
} else {
nextval[i] = next[i]
}
}
return nextval
}
/**
* KMP 算法分三分，第一步求next數組，第二步求nextval數組，第三步匹配
* http://blog.csdn.net/v_july_v/article/details/7041827
*
* 前兩步的求法
* http://blog.csdn.net/liuhuanjun222/article/details/48091547
*
*/
function KmpSearch(s, p) {
var i = 0;
var j = 0;
var sLen = s.length
var pLen = p.length
var next = getNextVal(p)
while (i < sLen && j < pLen) {
//①若是j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++
if (j == -1 || s[i] == p[j]) {
i++;
j++;
} else {
//②若是j != -1，且當前字符匹配失敗（即S[i] != P[j]），則令 i 不變，j = next[j]
//next[j]即爲j所對應的next值
j = next[j];
}
}
if (j == pLen)
return i - j;
else
return -1;
}
console.log(KmpSearch('abacababc', 'abab'))
你能夠將這種算法當作DFA （有窮狀態自動機）的一種退化寫法，但很是晦澀，它是世界第一次打破字符串快速匹配的困局，啓迪人們如何跳着匹配字符串了。性能
Boyer-Moore算法
Boyer-Moore算法是咱們文本編輯器進行diff時，使用的一種高效算法，比KMP快三到四倍，思想也是預處理模式串，獲得壞字符規則和好後綴規則移動的映射表，下面代碼中MakeSkip是創建壞字符規則移動的映射表，MakeShift是創建好後綴規則的移動映射表。ui
下面是阮一峯的文章，簡單介紹什麼是壞字符串與好後綴，但沒有如何介紹如何實現。
http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html
壞字符串還能輕鬆搞定，但好後綴就難了，都是n^2, n^3的複雜度，裏面的循環你們估計也很難看懂。。。
//http://blog.csdn.net/joylnwang/article/details/6785743
// http://blog.chinaunix.net/uid-24774106-id-2901288.html
function makeSkip(pattern) { //效率更高
var skip = {}
for (var n = pattern.length - 1, i = 0; n >= 0; n--, i++) {
var c = pattern[n]
if (!(c in skip)) {
skip[c] = i //最後一個字符串爲0，倒二爲1，倒三爲2，重複跳過
}
}
return skip
}
function makeShift(pattern) {
var i, j, c, goods = []
var patternLen = pattern.length
var len = patternLen - 1
for (i = 0; i < len; ++i) {
goods[i] = patternLen
}
//初始化pattern最末元素的好後綴值
goods[len] = 1;
//此循環找出pattern中各元素的pre值，這裏goods數組先看成pre數組使用
for (i = len, c = 0; i != 0; --i) {
for (j = 0; j < i; ++j) {
if (pattern.slice(i, len) === pattern.slice(j, len)) {
if (j == 0) {
c = patternLen - i;
} else {
if (pattern[i - 1] != pattern[j - 1]) {
goods[i - 1] = j - 1;
}
}
}
}
}
//根據pattern中個元素的pre值，計算goods值
for (i = 0; i < len; i++) {
if (goods[i] != patternLen) {
goods[i] = len - goods[i];
} else {
goods[i] = len - i + goods[i];
if (c != 0 && len - i >= c) {
goods[i] -= c;
}
}
}
return goods
}
function BMSearch(text, pattern) {
var i, j, m = 0
var patternLen = pattern.length
var textLen = text.length
i = j = patternLen - 1
var skip = makeSkip(pattern) //壞字符表
console.log(skip)
var goods = makeShift(pattern) //好後綴表
var matches = []
while (j < textLen) { //j 是給text使用
//發現目標傳與模式傳從後向前第1個不匹配的位置
while ((i != 0) && (pattern[i] == text[j])) {
--i
--j
}
//找到一個匹配的狀況
var c = text[j]
if (i == 0 && pattern[i] == c) {
matches.push(j)
j += goods[0]
} else {
//壞字符表用字典構建比較合適
j += Math.max(goods[i], typeof skip[c] === 'number' ? skip[c] : patternLen)
}
i = patternLen - 1 //回到最後一位
}
return matches
}
console.log(BMSearch('HERE IS ASIMPLE EXAMPLE', 'EXAMPLE'))
對於進階的單模式匹配算法而言，子串（前綴/後綴）的自包含，是相當重要的概念，是加速模式匹配效率的金鑰匙，而將其發揚光大的無疑是KMP算法，BM算法使用後綴自包含，從>後向前匹配模式串的靈感，也源於此，只有透徹理解KMP算法，纔可能透徹理解BM算法。
壞字符表，能夠用於加速任何的單模式匹配算法，而不只限於BM算法，對於KMP算法，壞字符表一樣能夠起到大幅增長匹配速度的效果。對於大字符集的文字，咱們須要改變壞字符表>的使用思路，用字典來保存模式串中的字符的跳轉步數，對於在字典中沒有查到的字符，說明其不在模式串中，目標串當前字符直接滑動patlen個字符。
BMH算法
BMH 算法是在BM算法上改進而來，捨棄晦澀複雜的後好綴算法，僅考慮了「壞字符」策略。它首先比較文本指針所指字符和模式串的最後一個字符，若是相等再比較其他m一1個字符。不管文本中哪一個字符形成了匹配失敗，都將由文本中和模式串最後一個位置對應的字符來啓發模式向右的移動。關於「壞字符」啓發和「好尾綴」啓發的對比，孫克雷的研究代表：「壞字符」啓發在匹配過程當中占主導地位的機率爲94．O3 ，遠遠高於「好尾綴」啓發。在通常狀況下，BMH算法比BM有更好的性能，它簡化了初始化過程，省去了計算「好尾綴」啓發的移動距離，並省去了比較「壞字符」和「好尾綴」的過程。
算法思想：
搜索文本時，從後到前搜索；
若是碰到不匹配時，移動pattern，從新與text進行匹配；
關鍵：移動位置的計算shift_table以下圖所示。
其中k爲Pattern[0 ... m-2]中，使Pattern [ k ] ==Text [ i+m-1 ]的最大值；
若是沒有能夠匹配的字符，則使Pattern[ 0 ]==Text [ i+m ]，即移動m個位置
若是與Pattern徹底匹配，返回在Text中對應的位置；
若是搜索完Text仍然找不到徹底匹配的位置，則返回-1，即查找失敗
function BMHSearch(test, pattern) {
var n = test.length
var m = pattern.length
var shift = {}
// 模式串P中每一個字母出現的最後的下標，最後一個字母除外
// 主串從不匹配最後一個字符，所須要左移的位數
for (var i = 0; i < m - 1; i++) {
shift[pattern[i]] = m - i - 1; //就是BM的壞字母表
}
// 模式串開始位置在主串的哪裏
var s = 0;
// 從後往前匹配的變量
var j;
while (s <= n - m) {
j = m - 1;
// 從模式串尾部開始匹配
while (test[s + j] == pattern[j]) {
j--;
// 匹配成功
if (j < 0) {
return s;
}
}
// 找到壞字符(當前跟模式串匹配的最後一個字符)
// 在模式串中出現最後的位置(最後一位除外)
// 所須要從模式串末尾移動到該位置的步數
var c = test[s + m - 1]
s = s + (typeof shift[c] === 'number' ? shift[c] : m)
}
return -1;
}
console.log(BMHSearch('HERE IS ASIMPLE EXAMPLE', 'EXAMPLE'))
console.log(BMHSearch('missipipi', 'pip'))
Sunday算法
Sunday算法思想跟BM算法很類似，在匹配失敗時關注的是文本串中參加匹配的最末位字符的下一位字符。若是該字符沒有在匹配串中出現則直接跳過，即移動步長= 匹配串長度+1；不然，同BM算法同樣其移動步長=匹配串中最右端的該字符到末尾的距離+1。
function sundaySearch(text, pattern) {
var textLen = text.length
var patternLen = pattern.length
if (textLen < patternLen)
return -1
var shift = {} //建立跳轉表
for (i = 0; i < patternLen; i++) {
shift[pattern[i]] = patternLen - i
}
var pos = 0
while (pos <= (textLen - patternLen)) { //末端對齊
var i = pos,
j
for (j = 0; j < patternLen; j++, i++) {
if (text[i] !== pattern[j]) {
var c = text[pos + patternLen]
pos += typeof shift[c] === 'number' ? shift[c] : patternLen + 1
break
}
}
if (j === patternLen) {
return pos
}
}
return -1
}
console.log(sundaySearch('HERE IS ASIMPLE EXAMPLE', 'EXAMPLE'))
console.log(sundaySearch('missipipi', 'pip'))
Shift-And和Shift-OR算法
這個算法已經超出筆者的能力，只是簡單給出連接
http://www.iteye.com/topic/1130001
bitmap算法思想
這個在騰訊面試題考過，但這個算法優缺點也太明顯，本文也簡單給出連接，供學霸們研究
http://www.tuicool.com/articles/aYfEvy
更多連接（裏面有更多算法實現與複雜度介紹）
http://blog.csdn.net/airfer/article/details/8951802/
像咱們這樣的日常人怎麼在項目用它們呢，可能在前端比較少用，但也不是沒有，如富文本編輯器，日誌處理，用了它們性能提高一大截。總之，不要每天作輕鬆的事，不然你沒有進步。
- 1. kmp算法實現字符串匹配
- 2. C#實現字符串匹配算法
- 3. 字符串匹配算法
- 4. 字符串匹配算法之___Sunday算法的java實現
- 5. 字符串匹配算法——KMP算法
- 6. 算法 - KMP算法(字符串匹配)
- 7. KMP 算法 —— 字符串匹配算法
- 8. 算法之「字符串匹配算法」
- 9. 字符串匹配算法--BM算法
- 10. 字符串匹配的KMP算法
- 更多相關文章...
- • R 字符串 - R 語言教程
- • Swift 字符串 - Swift 教程
- • ☆基於Java Instrument的Agent實現
- • 互聯網組織的未來：剖析GitHub員工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. kmp算法實現字符串匹配
- 2. C#實現字符串匹配算法
- 3. 字符串匹配算法
- 4. 字符串匹配算法之___Sunday算法的java實現
- 5. 字符串匹配算法——KMP算法
- 6. 算法 - KMP算法(字符串匹配)
- 7. KMP 算法 —— 字符串匹配算法
- 8. 算法之「字符串匹配算法」
- 9. 字符串匹配算法--BM算法
- 10. 字符串匹配的KMP算法