KMP算法，是由Knuth，Morris，Pratt共同提出的模式匹配算法，其对于任何模式和目标序列，都可以在线性时间内完成匹配查找，而不会发生退化，是一个非常优秀的模式匹配算法。本文就对该算法进行基本的介绍，由于水平有限，解释不恰当的地方，欢迎指出谢谢。
在KMP算法中，对于每一个模式串我们会事先计算出模式串的内部匹配信息，在匹配失败时最大的移动模式串，以减少匹配次数。
比如，在简单的一次匹配失败后，我们会想将模式串尽量的右移和主串进行匹配。右移的距离在KMP算法中是如此计算的:在已经匹配的模式串子串中，找出最长的相同的前缀和后缀，然后移动使它们重叠。
KMP算法对于朴素匹配算法的改进是引入了一个跳转表next[]数组。以模式字符串ABABABB为例，其跳转表为：
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|---|
| substr | A | B | A | B | A | B | B |
| next | -1 | 0 | 0 | 1 | 2 | 3 | 4 |
求解过程如下：候选串即为最长的相同的前缀和后缀串
（1）当 j 等于 0 的时候发生不匹配，即模式串第一个字符与主串i位置不匹配，应将i跳过当前位置，从下一个位置和模式串第一个字符继续比较，此时将 next[0] 设置为-1来表示特殊情况；
（2）当 j 等于 1 时发生不匹配，此时匹配的子串 S 为“A”，候选串只能是空串，下次匹配还是从模式串的下标0开始比较，即 next[1] 设为0；
（3）当 j 等于 2 时发生不匹配，此时匹配的子串 S 为“AB”，候选串只能是空串，下次匹配还是从模式串的下标0开始比较，即 next[2] 设为0；
（4）当 j 等于 3 时发生不匹配，此时匹配的子串 S 为“ABA”，候选串为是“A”，因此 next[3] 设为1；
（5）当 j 等于 4 时发生不匹配，此时匹配的子串 S 为“ABAB”，候选串为是“AB”，因此 next[4] 设为2；
（6）当 j 等于 5 时发生不匹配，此时匹配的子串 S 为“ABABA”，候选串为是“ABA”和“A”，选择长度大的子串“ABA”，因此 next[5] 设为3；
（7）当j等于6时发生不匹配，此时匹配的子串 S 为“ABABAB”，候选串为是“ABAB”和“AB”，选择长度大的子串“ABAB”，因此 next[6] 设为4；
为了更进一步的说明next的求解：
再以模式串ababaaababaa为例：
以主串为ABABCABCABABABBC， 模式串为ABABABB为例的匹配过程
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| substr | A | B | A | B | C | A | B | C | A | B | A | B | A | B | B | C |
| one | A | B | A | B | A(2) | B | B | |||||||||
| two | A | B | A(0) | B | A | B | B | |||||||||
| three | A | B | A(0) | B | A | B | B | |||||||||
| four | A | B | A | B | A | B | B |
通过模式串的4次移动，完成了对目标串的模式匹配。这里以匹配的第一步为例，当模式串（从0计数）在第4个位置处不匹配，next[4] = 2, 所以从模式串的第2个位置从新与不匹配处比较，得到第二步。当第二步中的不匹配位置的next值0时，表示第一个字符匹配不成功，则i向后移动一个，模式串从头开始匹配，得到第三步。
在整个匹配过程中，无论模式串如何向后滑动，目标串的输入字符都在不会回溯，直到找到模式串，或者遍历整个目标串都没有发现匹配模式为止。
关于求解 next 数组的方法：
如何利用 next[n] 求解 next[n+1]，减少重复计算呢？
求解 next[n+1] 的时候，由上边的分析可知，此时存在两个子串 a 和 b 是匹配的，即模式串中 0 到 k-1 的子串（对应 n 时的前缀）和子串 n-k 到 n-1 （对应 n 时的后缀）是相互匹配的，下面分两种情况求解 next[n+1]:
第一种情况：下标 k 处的字符与 n 处的字符匹配，则 0 到 k 位置的子串与 n-k 到 n 位置的子串匹配（例如 n+1 的情况（k=2）为：ABABA），显然有 next[n+1] = k + 1 = next[n] + 1
第二种情况：下标 k 处的字符与 n 处的字符不匹配，这样我们为了消除将0 到 k的子串与n处的不匹配，需要向前移动到 next[n] 处。假设 next[k] = k’,相当于找到了S串中的这么一对子串0~k’-1 和 n- (k’ - 1) 到n是匹配的，如果 k’ 处字符和 n 处字符匹配，这利用情况 1）中的办法求得 next[n+1] , 否则用同样的办法借助之前求得的 next 数组值来继续处理。（这一部分我也不是很懂？）
Java代码如下：
import java.util.Scanner;
public class KMPOfJava {
public static void main(String[] args) {
KMPOfJava kmp = new KMPOfJava();
Scanner in = new Scanner(System.in);
String str = "";
String substr = "";
int next[];
while (in.hasNext()){
str = in.nextLine();
substr = in.nextLine();
next = kmp.getNext(substr);
System.out.println(kmp.KMP(str, substr, next));
kmp.printNext(next);
}
}
/**
* 测试用例：
* 主串： ABABCABCACBAB
* 模式串：ABCAC
* 模式串：ABABAB
* 模式串：ABABABB
* 主串： abbababaaababaa
* 模式串：ababaaababaa
* */
/** KMP算法 */
public int KMP(String str, String substr, int next[]){
int i = 0, j = 0;
while (i < str.length() && j < substr.length()){
if (str.charAt(i) == substr.charAt(j)){//匹配
++i;
++j;
}else{//不匹配
j = next[j];//取出next数组对应j处的值
if (j == -1){//如果为第一个位置
j = 0;//从模式串的头部开始比较
++i;//主串后移一个位置
}
}
}
if (j == substr.length())
return i - substr.length();
else return -1;
}
/** 得到模式串的next数组 */
public int[] getNext(String substr){
int i = 0, j = -1;
//定义next数组，长度为模式串的长度
int next[] = new int[substr.length()];
//设置next初始位置为-1
next[0] = -1;
//求解next其他值（当前字符串的最长的相同的前缀和后缀）
while (i < substr.length() - 1){
//第一种情况：k处字符与n-k处字符匹配
if (j == -1 || substr.charAt(i) == substr.charAt(j)){
++i;
++j;
next[i] = j;
}else{//第二种情况：k处字符与n-k处字符不匹配
j = next[j];
}
}
return next;
}
/**打印next函数 */
public void printNext(int next[]){
for (int n : next){
System.out.print(n + " ");
}
System.out.println();
}
}