版權(quán)聲明：本文源自簡(jiǎn)書tianma，轉(zhuǎn)載請(qǐng)務(wù)必注明出處： http://www.lxweimin.com/p/e2bd1ee482c3
本文靈感來(lái)自于July的博客從頭到尾徹底理解KMP，并著重于Java實(shí)現(xiàn) :)。 現(xiàn)有字符串匹配算法有不少，如簡(jiǎn)單暴力的樸素算法(暴力匹配算法)、KMP算法、BM算法以及Sunday算法等，在這里僅介紹前兩種算法。
1. 樸素算法
樸素算法即暴力匹配算法，對(duì)于長(zhǎng)度為n的文本串S和長(zhǎng)度為m模式串P，在文本串S中是否存在一個(gè)有效偏移i，其中 0≤ i < n - m + 1，使得 S[i... i+m - 1] = P[0 ... m-1]（注：下標(biāo)從0開始），如果存在則匹配成功，否則匹配失敗。由于在匹配過程中一旦不匹配，就要讓模式串P相對(duì)于文本串S右移1，即i需要進(jìn)行回溯，其時(shí)間復(fù)雜度為O(n*m)。
Java實(shí)現(xiàn)：
// 定義接口
interface StringMatcher {
/**
* 從原字符串中查找模式字符串的位置,如果模式字符串存在,則返回模式字符串第一次出現(xiàn)的位置,否則返回-1
*
* @param source
* 原字符串
* @param pattern
* 模式字符串
* @return if substring exists, return the first occurrence of pattern
* substring, return -1 if not.
*/
int indexOf(String source, String pattern);
}
/**
* 暴力匹配
* <p>
* 時(shí)間復(fù)雜度: O(m*n), m = pattern.length, n = source.length
*/
class ViolentStringMatcher implements StringMatcher {
@Override
public int indexOf(String source, String pattern) {
int i = 0, j = 0;
int sLen = source.length(), pLen = pattern.length();
char[] src = source.toCharArray();
char[] ptn = pattern.toCharArray();
while (i < sLen && j < pLen) {
if (src[i] == ptn[j]) {
// 如果當(dāng)前字符匹配成功,則將兩者各自增1,繼續(xù)比較后面的字符
i++;
j++;
} else {
// 如果當(dāng)前字符匹配不成功,則i回溯到此次匹配最開始的位置+1處,也就是i = i - j + 1
// (因?yàn)閕,j是同步增長(zhǎng)的), j = 0;
i = i - j + 1;
j = 0;
}
}
// 匹配成功,則返回模式字符串在原字符串中首次出現(xiàn)的位置;否則返回-1
if (j == pLen)
return i - j;
else
return -1;
}
}
2. KMP算法
與樸素算法不同，樸素算法是當(dāng)遇到不匹配字符時(shí)，向后移動(dòng)一位繼續(xù)匹配，而KMP算法是當(dāng)遇到不匹配字符時(shí)，不是簡(jiǎn)單的向后移一位字符，而是根據(jù)前面已匹配的字符數(shù)和模式串前綴和后綴的最大相同字符串長(zhǎng)度數(shù)組next的元素來(lái)確定向后移動(dòng)的位數(shù)，所以KMP算法的時(shí)間復(fù)雜度比樸素算法的要少，并且是線性時(shí)間復(fù)雜度，即預(yù)處理時(shí)間復(fù)雜度是O(m)，匹配時(shí)間復(fù)雜度是O(n)。
next數(shù)組含義：代表在模式串P中，當(dāng)前下標(biāo)對(duì)應(yīng)的字符之前的字符串中，有多大長(zhǎng)度的相同前綴后綴。例如如果next [j] = k，代表在模式串P中，下標(biāo)為j的字符之前的字符串中有最大長(zhǎng)度為k 的相同前綴后綴。
KMP算法的核心就是求next數(shù)組，在字符串匹配的過程中，一旦某個(gè)字符匹配不成功，next數(shù)組就會(huì)指導(dǎo)模式串P到底該相對(duì)于S右移多少位再進(jìn)行下一次匹配，從而避免無(wú)效的匹配。
next數(shù)組求解方法：
- next[0] = -1。
- 如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
- 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
- 如果p[j] != p[k], 則令k=next[k],如果此時(shí)p[j]==p[k],則next[j+1]=k+1,如果不相等,則繼續(xù)遞歸前綴索引,令 k=next[k],繼續(xù)判斷,直至k=-1(即k=next[0])或者p[j]=p[k]為止
詳細(xì)的介紹及分析還請(qǐng)移步從頭到尾徹底理解KMP，在下語(yǔ)拙 :(
Java實(shí)現(xiàn)：
/**
* KMP模式匹配
* @author Tianma
*
*/
class KMPStringMatcher implements StringMatcher {
/**
* 獲取KMP算法中pattern字符串對(duì)應(yīng)的next數(shù)組
*
* @param p
* 模式字符串對(duì)應(yīng)的字符數(shù)組
* @return
*/
protected int[] getNext(char[] p) {
// 已知next[j] = k,利用遞歸的思想求出next[j+1]的值
// 如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
// 1. 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
// 2. 如果p[j] != p[k], 則令k=next[k],如果此時(shí)p[j]==p[k],則next[j+1]=k+1,
// 如果不相等,則繼續(xù)遞歸前綴索引,令 k=next[k],繼續(xù)判斷,直至k=-1(即k=next[0])或者p[j]=p[k]為止
int pLen = p.length;
int[] next = new int[pLen];
int k = -1;
int j = 0;
next[0] = -1; // next數(shù)組中next[0]為-1
while (j < pLen - 1) {
if (k == -1 || p[j] == p[k]) {
k++;
j++;
next[j] = k;
} else {
k = next[k];
}
}
return next;
}
@Override
public int indexOf(String source, String pattern) {
int i = 0, j = 0;
char[] src = source.toCharArray();
char[] ptn = pattern.toCharArray();
int sLen = src.length;
int pLen = ptn.length;
int[] next = getNext(ptn);
while (i < sLen && j < pLen) {
// 如果j = -1,或者當(dāng)前字符匹配成功(src[i] = ptn[j]),都讓i++,j++
if (j == -1 || src[i] == ptn[j]) {
i++;
j++;
} else {
// 如果j!=-1且當(dāng)前字符匹配失敗,則令i不變,j=next[j],即讓pattern模式串右移j-next[j]個(gè)單位
j = next[j];
}
}
if (j == pLen)
return i - j;
return -1;
}
}
3. 優(yōu)化的KMP算法（改進(jìn)next數(shù)組）
具體過程移步從頭到尾徹底理解KMP的3.3.8 Next 數(shù)組的優(yōu)化
在這里給出Java實(shí)現(xiàn)：
/**
* 優(yōu)化的KMP算法(對(duì)next數(shù)組的獲取進(jìn)行優(yōu)化)
*
* @author Tianma
*
*/
class OptimizedKMPStringMatcher extends KMPStringMatcher {
@Override
protected int[] getNext(char[] p) {
// 已知next[j] = k,利用遞歸的思想求出next[j+1]的值
// 如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
// 1. 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
// 2. 如果p[j] != p[k], 則令k=next[k],如果此時(shí)p[j]==p[k],則next[j+1]=k+1,
// 如果不相等,則繼續(xù)遞歸前綴索引,令 k=next[k],繼續(xù)判斷,直至k=-1(即k=next[0])或者p[j]=p[k]為止
int pLen = p.length;
int[] next = new int[pLen];
int k = -1;
int j = 0;
next[0] = -1; // next數(shù)組中next[0]為-1
while (j < pLen - 1) {
if (k == -1 || p[j] == p[k]) {
k++;
j++;
// 修改next數(shù)組求法
if (p[j] != p[k]) {
next[j] = k;// KMPStringMatcher中只有這一行
} else {
// 不能出現(xiàn)p[j] = p[next[j]],所以如果出現(xiàn)這種情況則繼續(xù)遞歸,如 k = next[k],
// k = next[[next[k]]
next[j] = next[k];
}
} else {
k = next[k];
}
}
return next;
}
}
4. 花絮
提到字符串匹配，或者說(shuō)字符串查找，我們會(huì)想到Java中的String類就有一個(gè)String.indexOf(String str);方法，那它使用的是什么算法呢？在這里截取JavaSE-1.8的源碼：
// String.indexOf(String str); 最終會(huì)調(diào)用該方法
/**
* Code shared by String and StringBuffer to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.(源字符數(shù)組)
* @param sourceOffset offset of the source string.(源字符數(shù)組偏移量)
* @param sourceCount count of the source string.(源字符數(shù)組長(zhǎng)度)
* @param target the characters being searched for.(待搜索的模式字符數(shù)組)
* @param targetOffset offset of the target string.(模式字符數(shù)組偏移量)
* @param targetCount count of the target string.(模式數(shù)組長(zhǎng)度)
* @param fromIndex the index to begin searching from.(從原字符數(shù)組的哪個(gè)下標(biāo)開始查詢)
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
if (fromIndex >= sourceCount) {
return (targetCount == 0 ? sourceCount : -1);
}
if (fromIndex < 0) {
fromIndex = 0;
}
if (targetCount == 0) {
return fromIndex;
}
char first = target[targetOffset];
int max = sourceOffset + (sourceCount - targetCount);
for (int i = sourceOffset + fromIndex; i <= max; i++) {
/* Look for first character. */
// 找到第一個(gè)匹配的字符的位置
if (source[i] != first) {
while (++i <= max && source[i] != first);
}
/* Found first character, now look at the rest of v2 *
if (i <= max) {
// 找到了第一個(gè)匹配的字符，看余下的是否完全匹配
int j = i + 1;
int end = j + targetCount - 1;
for (int k = targetOffset + 1; j < end && source[j]
== target[k]; j++, k++);
if (j == end) {
/* Found whole string. */
return i - sourceOffset;
}
// 如果不完全匹配，因?yàn)橥鈱觙or循環(huán)中有i++，即i+1繼續(xù)匹配
// 故而該方法本質(zhì)上就是字符串匹配的樸素算法
}
}
return -1;
}
通過對(duì)代碼片段的注釋和分析可以看出，Java源碼中的String.indexOf(String str); 內(nèi)部所使用的算法其實(shí)就是字符串匹配的樸素算法...
源碼github地址:
StringMatchSample
重要參考:
從頭到尾徹底理解KMP
