KMP算法理解

学了不下于三次，每次都是学了忘，忘了学，这次刷题碰到了，一定要记录下思路和需要注意的点

1.字符串匹配算法：

leetcode-28 字符串匹配
常规解法思路：使用两个指针i，j，分别指向haystack(主串) 、needle(子串)，将子串和主串一一匹配。

public class S28_strStr {
    public static int strStr(String haystack, String needle) {
        if(haystack.length() == 0 && needle.length() == 0){
            return 0;
        }
        char[] hayChar = haystack.toCharArray();
        char[] needleChar = needle.toCharArray();
        int i = 0;
        int j = 0;
        while (i < hayChar.length){

            while (i < hayChar.length && j < needleChar.length && hayChar[i] == needleChar[j]){
                i++;
                j++;
            }
            if(j == needle.length()){
                return i - j;
            }else {
                i -= j;
                j = 0;
            }
            i++;
        }
        return -1;
    }
}

但是这种解法时间复杂度为O(n*m)，其中n为主串长度，m为子串长度。考虑改进。

2.KMP算法

常规思路在遇到i和j指向的字符不匹配时的，j直接置为0，i置为i-j，再自增i++，表示为开始与j=0时指向的字符串匹配的i的下一个字符：i+1。
KMP的改进在于遇到不匹配的字符时，i不需要回退，j也不需要回退到0，而是回退到[0-(j-1)]这段字符串中的最长匹配前后缀的指针那里。这个最长匹配前后缀使用一个数组存放起来，也就是经常说的next数组。
举个例子：
haystack：BBC ABCDAB ABCDABCDABDE
needle:ABCDABD
nex数组：

i=10 j=6时发现不匹配

BBC ABCDAB ABCDABCDABDE
    ABCDABD

此时i不用回退，j=next[j]

BBC ABCDAB ABCDABCDABDE
        ABCDABD

继续匹配 发现：i=17 j=6时又不匹配，j=next[j] 此时则可以匹配上

BBC ABCDAB ABCDABCDABDE
           ABCDABD
BBC ABCDAB ABCDABCDABDE
               ABCDABD

重点：next数组含义：表示j当前所指向的字符之前的子串中，最长相同前后缀
解释一下相同前后缀：ABCDABD
j为1时 ，j-1 = 0，其前面的子串为A，前缀[]，后缀[]，next[j] = 0;
j为2时 ，j-1 = 1，其前面的子串为AB，前缀[A]，后缀[B]，next[j] = 0;
j为3时 ，j-1 = 2，其前面的子串为ABC，前缀[A,AB]，后缀[C,BC]，next[j] = 0;
j为4时 ，j-1 = 3，其前面的子串为ABCD，前缀[A,AB,ABC]，后缀[D,CD,BCD]，next[j] = 0;
j为5时 ，j-1 = 4，其前面的子串为ABCDA，前缀[A,AB,ABC,ABCD]，后缀[A,DA,CDA,BCDA]，next[j] = 1;
j为6时 ，j-1 = 5，其前面的子串为ABCDAB，前缀[A,AB,ABC,ABCD,ABCDA]，后缀[B,AB,DAB,CDAB,BCDAB]，next[j] = 2;
next数组求解方法如下：

public static int[] getNext(String needle){
        char[] needleChar = needle.toCharArray();
        int[] next = new int[needleChar.length];
        next[0] = -1;
        int i = 0;
        int j = -1;
        while (i < needleChar.length - 1){
            if(j == -1 || needleChar[i] == needleChar[j]){
                i++;
                j++;
                next[i] = j;
            }else {
                j = next[j];
            }
        }
        return next;
    }

需要注意的细节：

1. next[0] = -1，是从i = 1开始计算next[i]的
2. 因为是先i++,j++再next[i] = j的 因此i的范围是1-needleChar.length-1，否则会数组越界

字符串匹配KMP算法如下：

    public static int strStr_KMP(String haystack, String needle){
        if(needle.length() == 0){
            return 0;
        }
        char[] hayChar = haystack.toCharArray();
        char[] needleChar = needle.toCharArray();
        int i = 0;
        int j = 0;
        int[] next = getNext(needle);
        if(next == null){
            return 0;
        }
        while (i < hayChar.length && j < needle.length()){
            if(j == -1 || hayChar[i] == needleChar[j]){
                i++;
                j++;
            }else {
                j = next[j];
            }
        }
        if(j == needleChar.length){
            return i-j;
        }else {
            return -1;
        }
    }

细节：
需考虑needle为""的情况