【KMP算法】彻底吃透字符串匹配算法

什么是KMP算法

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。

朴素的暴力匹配

下面我们来图解字符串匹配的暴力解法

 对于上述原始串和模式串的匹配，思路如下

 初始化i，j两个指针，分别指向原始串和模式串的首个字符

之后，我们仅需比较i，j指针指向字符是否一致，如果一致就都向后移动，如果不一致，如下图：

此时发现i指针指向元素和j指针指向不一致，此时只需要将i指针回溯到B位置，j指针回溯到A位置即可开启下一轮比较；

重复上述步骤，直至找到模式串或者遍历完主串。

暴力解法比较简单，朴素，下面附上一个简单实现

public int indexOf(String source, String target){
    char[] sCharArray = source.toCharArray();
    char[] tCharArray = target.toCharArray();

    for(int i = 0 ; i <= sCharArray.length - tCharArray.length; i++){
        int j = 0;
        while(j < tCharArray.length){
            if(sCharArray[i+j] != tCharArray[j])
                break;
            j++;
        }
        if(j == tCharArray.length)
            return i;
    }
    return -1;
}

假若原始串的字符长度为m， 模式串的字符长度为n,  原始串不存在子串匹配模式串，我们需要匹配的次数 = (m - n + 1) * n 次， 经过简化，时间复杂度 = O(n^2)。

有没有更优解？

如果是人为来寻找的话，肯定不会再把 i 再移动到B位置，因为原始串匹配失败的位置前面除了第一个A之外再也没有A了，那我们为什么能知道主串前面只有一个A？因为我们已经知道前面三个字符都是匹配的！（这很重要）。所以移动过去肯定也是不匹配的！有一个想法，i可以不动，我们只需要移动j就可以达到下一轮匹配位置，如下图：

 KMP核心思想

“利用已经部分匹配这个有效信息，保持i指针不回溯，通过修改j指针，让模式串尽量地移动到有效的位置“。

所以，整个KMP的重点就在于当某一个字符与主串不匹配时，我们应该如何知道j指针要移动到哪？

下面通过一个具体案例进行分析

 在上图，我们发现 i 和 j 指向元素不匹配，应该怎么移动指针，获取下一轮最优的比较方案呢？

 通过观察，我们可以直观的发现， 在当前位置原始串和模式串字符不匹配时，模式串的前置子串   ABA 和主串是完全匹配的。

 对于前置子串ABA， 是存在公共前后缀A的， 那下一轮，可以直接将 i 位置和 模式串的首位置的下一位进行比较。

通过上述例子，我们可以发现，当模式串和主串在 第 j 位匹配不上时， 如果第 j 位前的子串存在相同前后缀。那么，我们可以匹配前缀后一位元素。也不难发现，要匹配的索引就是相同前后缀的长度，在上个case中即1，也就是模式串的B位置。 

那么，我们只需要预先把模式串每一位对应的最长前后缀求解出来，就可以在主串和模式串不匹配时快速找到模式串下一轮的匹配位置。

但是需要注意的是，如果模式串的首位和主串当前位匹配不上， 主串的当前指针需要后移。

所以，kmp的核心思想 就是如何求解模式串每一位的最长公共前后缀，我们称之为next数组。

如何求解next数组

下面我们举例分析

我们用一个next数组存储当前位的最大公共前后缀长度；

当模式串索引 = 0 时，子串为 A， 不存在最长公共前后缀，所以 next[0] = 0

当模式串索引 = 1 时，子串为AB， 这里设置两个指针 i ， j ， i = 0 -> 代表当前子串前缀的末尾指针， j = 1 -> 代表当前子串后缀的末尾指针。

1. 从 j = 1 开始依次求取每一位的最大公共前后缀长度。

2. 判断 i ，j 指向字符是否一致，如果不一致，则可能在 当前 i 指针 前，存在 指针指向字符 和 j 指向 一致，此时需要向前回溯进行比较；

那么怎么回溯呢？ 是 j 从下一位， i 从头开始比较吗？又走暴力匹配的老路？ 当然没那么傻。

既然匹配到了这一位， i ， j 之前必然是存在相同公共前后缀的。 那对于 i 指针， 如果也存在相同前后缀，那么，是否可以直接匹配，  i 指针前的子串的 最大相同前后缀长度 位的索引？ 注意 这里用到了上一节 KMP核心思想 里的结论。 也就是让 i = next[i - 1]； 继续比对 i ，j 对应 字符。

这时候还不匹配怎么办？ 简单， 继续找上一位 最大相同前后缀长度 位索引，直至匹配 或者 i = 0;

3. 这一轮匹配完了， 该给结论了， 如果 i， j 指针指向 字符相等， 那么 i 后移一位， next[j] = i, 也就等于 当前最大前后缀长度。如果 i， j 指针指向字符不想等呢？ 那就 j + 1，继续进行下一轮查找嘛，此时注意 i = 0。

4. 这样遍历完就把next数组都求解出来了， 其实仔细想想也很好理解，求解next数组用到了 kmp的核心思想，减少比对次数嘛。

完整代码

下面附上一个我手写的kmp算法，也应该比较好理解。

public static int indexOf(String source, String target) {
        int i = 0, j = 0;
        int[] next = getNext(target);
        char[] sourceArray = source.toCharArray(), targetArray = target.toCharArray();

        while (i < source.length() && j < target.length()) {
            if (sourceArray[i] == targetArray[j]) {
                i++;
                j++;
            } else if (j == 0) {
                i++;
            } else {
                j = next[j - 1];
            }
        }
        if (j == target.length()) {
            return i - j;
        }
        return -1;
    }

    private static int[] getNext(String target) {
        int[] next = new int[target.length()];
        char[] array = target.toCharArray();
        int i = 0;
        for (int j = 1; j < target.length(); j++) {
            while (i > 0 && array[i] != array[j]) {
                i = next[i - 1];
            }
            if (array[i] == array[j]) {
                i++;
                next[j] = i;
            }
        }
        return next;
    }