KMP算法原理

所有下标从0开始

子串的定位操作通常称为串的模式匹配，它求的是子串(或称模式串)在主串中的位置。

前缀：除最后一个字符外，字符串的所有头部子串。
后缀：除第一个字符外，字符串的所有尾部子串。
部分匹配值：字符串的前缀和后缀的最长相等前后缀长度。

暴力匹配O(mn)：匹配失败后，模式串指针j回退到初始位置(0)，主串指针i回退到本轮匹配初始位置的下一个位置(3 + 1=4)。
KMP算法O(m+n)：根据模式串中已成功匹配子串(abcab)的特点，不需要全部回退，i保持不动，j回退到已成功匹配子串的最长相等前缀的下一个位置即可(ab后面的c的位置，即下标2)。因此，我们可以建立一个和模式串等长的数组next，存储j位置匹配失败时j的下一个位置。next[j]的值为pattern[1 ~ j-1]的部分匹配值，即最长相等前缀 或 最长相等后缀 的长度。

采用数学归纳法：

1. next[0] = -1; // 模式串第0个匹配失败，i不动，赋值j=-1，则++i;++j后等效于模式串第0个字符与主串下一个字符相比。

2. 设next[i] = j;

   则pattern[0 ~ i-1]中，最长相等前缀为pattern[0 ~ j-1]，最长相等后缀为pattern[i-j ~ i-1]；

   因此，pattern[0~i]最长相等前后缀 只需比较 pattern[0 ~ j] 和 pattern[i-j ~ i] 即可(最长相等前后缀各向后扩一个)。

   // pattern[0~i] 可能达到的 最长相等前后缀 即为 pattern[0 ~ j] 和 pattern[i-j ~ i]，要求pattern[j] == pattern[i]
   // 若pattern[j] != pattern[i]，则问题转变为 pattern[0 ~ j]为模式串 和 pattern[i-j ~ i]为主串的 匹配问题
   // (pattern[0 ~ j-1] 和 pattern[i-j ~ i-1]已成功匹配，且pattern[j] != pattern[i]，则模式串 指针 应该根据next数组前跳)
   
   while (j !=-1 && pattern[i] != pattern[j])
   	j = next[j]; // j < i，next[i]之前即next[0 ~ i-1]已求得
   next[i + 1] = j + 1;
   

   

3. 还有一个问题，text[i]和pattern[j]匹配失败，j=next[j]，新的pattern[j]或和老的pattern[j]相等，则又要重新跳转，因此，我们应该保证pattern[j] != pattern[next[j]]

   while (j !=-1 && pattern[i] != pattern[j])
   	j = next[j]; // j < i，next[i]之前即next[0 ~ i-1]已求得
   if (pattern[i + 1] == pattern[j + 1])
       next[i + 1] = next[j + 1]; // 不用递归跳转，因为next是依次加入的，若 pattern[j + 1] == pattern[next[j + 1]]，则将跳转使得其不相等，所以pattern[i+1]不可能连续等于pattern[j + 1]和pattern[next[j + 1]]
   else
   	next[i + 1] = j + 1;
   

import java.util.Random;

public class Main {

    // 生成随机字符串
    public static String randomString(String range, int length) {
        Random random=new Random();
        StringBuffer sb=new StringBuffer();
        for (int i = 0; i < length; i++) {
            sb.append(range.charAt(random.nextInt(range.length())));
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            String text = randomString("abcdefg", 1000);
            String pattern = "abc";

            int ref = text.indexOf(pattern);
            int out = indexOf(text, pattern);
            int kmp = indexOfByKMP(text, pattern);

            System.out.printf("ref: %10d, out: %10d, kmp: %10d\n", ref, out, kmp);
            assert ref == out;
            assert ref == kmp;
        }
    }

    // 暴力匹配
    public static int indexOf(String text, String pattern) {
        int i = 0, j = 0;
        while (i < text.length() && j < pattern.length()) {
            if (text.charAt(i) == pattern.charAt(j)) {
                ++i;
                ++j;
            } else {
                i = i - j + 1;
                j = 0;
            }
        }
        if (j == pattern.length())
            return i - pattern.length();
        else
            return -1;
    }

    private static int[] getNext(String pattern) {
        int[] next = new int[pattern.length()];

        int i = 0, j = -1;
        next[i] = j;

        while (i < pattern.length() - 1) {
            if (j != -1 && pattern.charAt(i) != pattern.charAt(j))
                j = next[j];
            ++i;
            ++j;
            if (pattern.charAt(i) == pattern.charAt(j))
                next[i] = next[j];
            else
                next[i] = j;
        }

        return next;
    }

    // KMP算法
    public static int indexOfByKMP(String text, String pattern) {
        int[] next = getNext(pattern);

        int i = 0, j = 0;
        while (i < text.length() && j < pattern.length()) {
            if (j == -1 || text.charAt(i) == pattern.charAt(j)) {
                ++i;
                ++j;
            } else {
                j = next[j];
            }
        }
        if (j == pattern.length())
            return i - pattern.length();
        else
            return -1;
    }
}