KMP模式匹配算法

概述：实现KMP模式匹配算法
KMP算法：串的模式匹配指的是在主串中查找模式串的过程，主要有Brute-Force算法和KMP算法
    Brute-Force算法：
        Brute-Force算法是最简单的暴力查找，它从主串的第一个字符开始和模式串的第一个字符进行比较，如果相等，则继续比较后续字符；否则从主串的第二个字符开始和模式串重复前一步操作，直到模式串的所有字符都和主串匹配上。
    KMP算法：
        Brute-Force算法效率很低，原因在于对于某些字符做了很多次重复的比较，如果主串长度为m，模式串长度为n，最坏的情况下，时间复杂度为O（m×n）。
      
        KMP算法是利用了部分匹配的结果，跳过重复的比较，具体做法是将指向模式串的下标移动一定的步数。通过分析后可以发现，当某一个位置匹配失败时，需要跳过的位数只和模式串有关，由此可以得到模式串对应的next数组，在模式串和主串匹配过程中，当匹配失败时，根据next数组即可得到模式串下一次需要指向的位置。
       
        KMP算法的大致分为两块：求解模式串的next数组的函数；根据next数组进行匹配得到匹配结果。
       
        next数组：
            要得到next数组，我们先了解一下字前缀和后缀的概念：前缀是指除了最后一个字符外的字符串的全部以第一个字母开头的（真）子串；后缀是指除了第一个字符外的字符串的全部以最后一个字符结尾的（真）子串。
            我们先求出“最大长度数组”，“最大长度就是”前缀和后缀的最长的共有元素的长度。以"ABCDABD"为例：
            －  "A"的前缀和后缀都为空集，共有元素的长度为0；
            －  "AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；
            －  "ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
            －  "ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
            －  "ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；
            －  "ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；
            －  "ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。
           
            所以“最大长度数组”是[0, 0, 0, 0, 1, 2, 0]
            next数组是将“最大长度数组”往后移一位，并将第一个元素赋值为-1
           
        得到匹配结果：
            如果模式串的第一个字符就匹配失败，或者字符匹配成功，则模式串和主串的下标都+1；若模式串部分匹配，则模式串的下标j=next[j]
           

 

实现思路：
    在求next数组的时候，我们可以发现，前缀后缀的共有元素，其第一个字符必定与模式串第一个字符相等，其最后一个字符与后缀最后一个字符相等（后面这个条件在实现时并没有用到）。

 

实现：

public class KMP {
    /**
     * 返回模式串在主串中第一次出现的起始位置
     * 
     * @param string
     *            主串
     * @param subString
     *            模式串
     * @return 模式串在主串中第一次出现的起始位置
     */
    public int find(String string, String subString) {
        if (string == null || string.length() == 0 || subString == null
                || subString.length() == 0) {
            return -1;
        }
        int[] next = getNext(subString);
        int i = 0;
        int j = 0;
        while (i < string.length()) {
            // 模式串的第一个字符就不匹配，或者对应字符匹配，主串和模式串的下标都往后移一位
            if (j == -1 || string.charAt(i) == subString.charAt(j)) {
                i++;
                j++;
            } else {
                j = next[j];
            }
            // 如果匹配到了，就返回模式串在主串中第一次出现的起始位置
            if (j == subString.length()) {
                return i - j;
            }
        }
        return -1;
    }

    /**
     * 获取next数组
     * 
     * @param subString
     *            模式串
     * @return next数组
     */
    private int[] getNext(String subString) {
        // 入参校验
        if (subString == null || subString.length() <= 1) {
            return new int[]{-1};
        }

        int length = subString.length();
        int[] next = new int[length];

        // 第一个元素设置为0
        next[0] = 0;

        // 得到最大长度数组
        for (int index = 1; index < length; index++) {
            // 每次开始找对应位的最大长度时，将前缀和后缀下标重置为起始位置
            next[index] = getMaxPubStr(subString.substring(0, index),
                    subString.substring(1, index + 1));
        }

        // 得到next数组(将数组元素后移一位，第一个元素赋值为-1)
        for (int k = next.length - 1; k > 0; k--) {
            next[k] = next[k - 1];
        }
        next[0] = -1;

        return next;
    }

    /**
     * 获取最大公共子串长度
     * 
     * @param pre
     *            前缀
     * @param suf
     *            后缀
     * @return 最长子串长度
     */
    private int getMaxPubStr(String pre, String suf) {
        int len = pre.length();
        int index = len;
        String subPre = "";
        String subSuf = "";

        while (index > 0) {
            subPre = pre.substring(0, index);
            subSuf = suf.substring(len - index);
            if (subPre.equals(subSuf)) {
                break;
            }
            index--;
        }
        return index;
    }
}

参考文章：
https://blog.youkuaiyun.com/buaa_shang/article/details/9907183
https://blog.youkuaiyun.com/v_JULY_v/article/details/7041827