KMP算法，寻找大型字符串中，给出子串出现的位置或次数

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * kmp算法：用于大型字符串中寻找子串出现的位置或次数
 * 为避免暴力遍历中 对字符串每次的回溯比较
 * 在kmp中，源字符串（text）比较的指针不回溯，子串的指针不一定回溯到起始位置
 * 对子串寻找最长公共前后缀的表，每次回溯时，在表中找到已经比较的字符串的值，回退子串的指针
 */
public class KMP {
    /**
     * 得到pattern的最长公共前后缀的表
     * eg:
     * a:           0
     * ab:  a!=b    0
     * aba: (0)a==a(2)  1
     * abab:    (1)b==(3)b    1+1
     * ababc:   (2)a!=(4)c    0
     * @param pattern ababc
     * @return {0，0，1，2，0}
     */
    static int[] calculateMaxMatchLengths(String pattern) {
        int[] maxMatchLengths = new int[pattern.length()];
        int maxLength = 0;
        for (int i = 1; i < pattern.length(); i++) {
            while (maxLength > 0 && pattern.charAt(maxLength) != pattern.charAt(i)) {
                maxLength = maxMatchLengths[maxLength - 1];
            }
            if (pattern.charAt(i) == pattern.charAt(maxLength)) {
                maxLength++;
            }
            maxMatchLengths[i] = maxLength;
        }
        return maxMatchLengths;
    }

    /**
     * 在 text 中寻找 pattern，返回所有匹配的位置开头
     */
    static List<Integer> search(String text, String pattern) {
        List<Integer> positions = new ArrayList<>();//记录所有匹配的位置开头
        int[] maxMatchLengths = calculateMaxMatchLengths(pattern);//得到每次需要回退的子串的指针值
        int count = 0;//代表子串的指针值
        for (int i = 0; i < text.length(); i++) {//i代表源字符串中的指针值，它将不会回退
            while (count > 0 && pattern.charAt(count) != text.charAt(i)) {
                count = maxMatchLengths[count - 1];//子串指针位置与源字符串指针位置的字符不相同时，子串具体回退的值
            }
            if (pattern.charAt(count) == text.charAt(i)) {
                count++;//在两个字符串中某一位置相同时，子串指针后移
            }
            if (count == pattern.length()) {
                positions.add(i - pattern.length() + 1);//记录完全匹配成功的位置
                count = maxMatchLengths[count - 1];//回退子串的count指针，继续向后比较
            }
        }
        return positions;
    }
    public static void main(String[] args) {
        int[] next = calculateMaxMatchLengths("ababc");
        System.out.println(Arrays.toString(next));//[0, 0, 1, 2, 0]
        List<Integer> search = search("ababbabaababcababc", "ababc");
        System.out.println(search);//[8, 13]
    }
}

总结：
    计算最长公共前后缀表（calculateMaxMatchLengths方法）指针回退的思想 与 搜索源字符串中子串出现位置（search方法） 的子串指针回退思想几乎一致

在Java中，字符串的contains方法，使用的是两个字符串暴力回溯的方法（即每次比较，两者都回到开始的位置重新比较），因为开发工程师认为，比较的字符串都不会太长，短字符串使用暴力回溯的空间复杂度等优于kmp算法。