KMP算法是用來查看一個字符串是否包含另一個字符串的算法，暴力求解的時間復雜度是O(m*n)，而KMP算法的時間復雜度是O(m+n)，KMP算法的關鍵概念如下：
- 前綴 abcdab的前綴集合為a,ab,abc,abcda
- 后綴 abcdab的后綴集合為bcdab,cdab,dab,ab,b
- 部分匹配值 部分匹配值就是前綴和后綴最長的共有元素的長度，比如abcdab前綴和后綴最長的共有元素是ab,其長度是2
- next值 當前字符前（不含當前字符）的字符串的部分匹配值，比如abcdab最后b的next值就是abcda的部分匹配值，也就是1
- 部分匹配值數組 設一個字符串string的長度為n，則部分匹配值數組array有n個元素，且array[i]的值為字符串string.sub(0, i+1)的部分匹配值，比如abcdab的部分匹配值數組為0,0,0,0,1,2
- next數組 設一個字符串string的長度為n，則next數組array有n個元素，且array[i]的值為字符串string.sub(0, i+1)的next值，特別的， array[0]永遠等于-1,array[1]永遠等于0, next數組可以用部分匹配值數組右移，然后在第一個元素補上-1得到。例如abcdab的部分匹配值數組為0,0,0,0,1,2,右移后為0,0,0,0,1,補充-1后為-1,0,0,0,0,1
next數組的作用在于計算模版P匹配字符串A失配后，需要在當前位置后移多少位繼續匹配。設失配字符為模版P的第i個字符，計算公式為distance = i - next(i)
實例代碼如下：
public class KMP {
private static int[] getNextArray(final String pattern) {
if (pattern == null || pattern.isEmpty()) {
return null;
}
int[] next = new int[pattern.length()];
next[0] = -1;
int k = -1;
int j = 0;
while (j < (pattern.length() - 1)) {
if (k == -1 || pattern.charAt(k) == pattern.charAt(j)) {
k++;
j++;
next[j] = k;
} else {
k = next[k];
}
}
return next;
}
private static void printArray(int[] arr) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i]);
sb.append(' ');
}
sb.append('\n');
System.out.print(sb.toString());
}
public static int kmpFind(final String src, final String pattern) {
if (src == null || pattern == null) {
return -1;
}
int lenSrc = src.length();
int lenPattern = pattern.length();
if (lenSrc < lenPattern) {
return -1;
}
int[] next = getNextArray(pattern);
if (next == null) {
return -1;
}
int result = -1;
int i = 0;
while (i < lenSrc) {
int j = 0;
while (j < lenPattern) {
if (src.charAt(i) != pattern.charAt(j)) {
break;
}
i++;
j++;
}
if (j < lenPattern) {
int move = j - next[j];
i = i - j + move;
result = -1;
} else {
result = i - lenPattern;
break;
}
}
return result;
}
public static void main(String[] argv) {
System.out.print(String.format("find %s in %s : %d\n", argv[1],
argv[0],
kmpFind(argv[0], argv[1])));
}
}
