时间复杂度：O(n+m)

S = ababcabcacbab
T = abcac
从S的第1个位置开始匹配，当T匹配到S的第3个位置时不相等，可以不回溯S的下一个位置（即第2个位置）重新匹配，因为当前的S串字符a与T的第1个字符a相等，可以使T直接移到S的第3个位置重新匹配。
S = ababcabcacbab
T = abcac
从S的第3个位置开始匹配，当T匹配到S的第7个位置时不相等，同样S不需要回溯，观察知T可以直接移动到S的第6个位置开始匹配。

以此类推，那么如何知道T应该移动到哪里呢？

• 设 j 表示模式串（即T串）的第 j 个位置，下一个移动的位置是 next[j]，则：
  如果 j = 0：next[j] = 0；
  如果 j = 1：next[j] = 1；
  否则计算 j 前面的字符串前缀和后缀相等的最大个数num，next[j] = num+1；

示例

解析

• next数组改进
  当出现S = aaabaaaab，T = aaaa时会发生多次无意义的比较，那么可以比较当前 i 与next[i]位置对应字符是否一样，若一样则当前next值为next[i]对应字符的next值，否则不变。如下表所示：

nextval

参考链接

以下为可运行KMP算法代码（与上述描述有出入，下标从0开始，对应地next[j] 的值比描述的少1）

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);

        String s = cin.next();
        String t = cin.next();

        //ababcabcacbab abcac
        //abcabcabca abc
        //aaa aa
        KMP(s, t);
    }

    private static void KMP(String s, String t) {
        int n = s.length();
        int m = t.length();

        int[] nex = new int[t.length()+1];
        getNex(t, nex);

        int i = 0;
        int j = 0;

        int cnt = 0; //记录匹配次数

        while(i < n){
            while(j != -1 && s.charAt(i) != t.charAt(j)){
                j = nex[j]; //不匹配时回溯
            }
            i++;
            j++;

            if(j == m){ //匹配时
                j = nex[j]; //匹配重叠时要回溯的位置
//                j = 0; //匹配不重叠时要回溯的位置

                cnt ++;
                System.out.println("当前匹配成功的下标：" + (i-m));
            }
        }
        System.out.println("匹配成功" + cnt + "次！");
    }

    private static void getNex(String t, int[] nex){
        nex[0] = -1;
        int i = 0;
        int j = -1;

        int len = t.length();
        while(i < len){
            while(j != -1 && t.charAt(i) != t.charAt(j)){ //不匹配时
                j = nex[j]; //回溯
            }
            nex[++i] = ++j; //更新nex数组（当前i所对应的回溯位置）
        }
    }
}