匹配字符串之——KMP算法深入理解

KMP算法的用途

一般在字符串匹配的时候，我们通常想到的就是使用KMP算法来处理。

KMP的使用，在网上有很多实例，但是讲得很让人容易接受的不是很多，但总感觉那层窗户纸没有捅破，这里我结合前人的知识，讲下自己的理解，希望大家多指教。

常规暴力匹配法

有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？
预处理时间 O(0)
时间复杂度为0(N*M)

/**
     * 暴力匹配法
     *
     * @param text 原字符串
     * @param text2 要匹配的串
     * @return
     */
    private static int violentMatch(String text, String text2) {
        int i = 0;
        int j = 0;
        while (i < text.length() && j < text2.length()) {
            if (text.charAt(i) == text2.charAt(j)) {
                i++;
                j++;
            } else {
                i = i - j + 1;
                j = 0;
            }
        }
        if (j == text2.length()) {
            return i - j;
        } else {
            return -1;
        }
    }

使用KMP算法

如题：有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

1. 字符串BBC ABCDAB ABCDABCDABDE的第一个字符与搜索字符串的第一个字符进行比较，因为B与A不匹配，所以搜索词后移一位。
   
   
2. 因为B与A不匹配，搜索词再往后移。
3. 就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。
   
4. 接着比较字符串和搜索词的下一个字符，还是相同。
5. 直到字符串有一个字符，与搜索词对应的字符不相同为止。
   
6. 这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这就是上面所展示的暴力匹配法，这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。
7. 一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。
8. 怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》。这张表是如何产生的，后面再说，这里只要先用就可以了。
9. 已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数： 移动位数 = 已匹配的字符数 - 对应的部分匹配值
   因为 6 - 2 等于4，所以将搜索词向后移动4位。
   
10. 因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（“AB”），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。
11. 因为空格与A不匹配，继续后移一位。
12. 逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。
13. 逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

部分匹配表的生成

首先，要了解两个概念：“前缀"和"后缀”。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。即：在这种情况下，向右移动位数也可以这样表示：已匹配字符6-上一个字符B对应的最大长度2=4，向右移动4位。
由此可得：

失配时，模式串向右移动的位数为：已匹配字符数-失配字符的上一位字符所对应的最大长度值。

next数组的求解思路

    /**
     * 求next数组
     * @param dest
     * @return
     */
    private static int[] kmpNext(String dest) {
        int[] next = new int[dest.length()];
        next[0] = 0;//模板字符串的第一个字符最大前后缀长度固定为0
        //for循环从第二个字符开始，依次计算每一个字符对应的next值
        for (int i = 1, j = 0; i < dest.length(); i++) {
            //重点，难点：递归求最大的相同的前后缀长度
            while (j > 0 && dest.charAt(j) != dest.charAt(i)) {
                j = next[j - 1];
            }
            //如果相等，那么最大相同前后缀长度加1
            if (dest.charAt(i) == dest.charAt(j)) {
                j++;
            }
            next[i] = j;
        }
        return next;
    }

1. 已知前一步计算时最大相同的前后缀长度为j（j>0），即dest[0]到dest[j-1]；
2. 此时比较搜索词第j项与上面的字符串比较
3. 如果相等，那么很简单跳出while循环;
4. 如果不相等，那么只要求dest[j-1]这个位置上，即next[j-1]来求最大的相同前后缀。

KMP的整体时间复杂度为O(m + n)
附代码如下

class KmpTest {
    public static void main(String[] args) {
        String text = "BBC ABCDAB ABCDABCDABDE";
        String text2 = "ABCDABD";
//        System.out.println(violentMatch(text, text2));
        int[] ints = kmpNext(text2);
        int res = kmp(text, text2, ints);
        System.out.println(res);
        System.out.println("==================================");
        for (int anInt : ints) {
            System.out.println(anInt);
        }
    }

    /**
     * 暴力匹配法
     *
     * @param text
     * @param text2
     * @return
     */
    private static int violentMatch(String text, String text2) {
        int i = 0;
        int j = 0;
        while (i < text.length() && j < text2.length()) {
            if (text.charAt(i) == text2.charAt(j)) {
                i++;
                j++;
            } else {
                i = i - j + 1;
                j = 0;
            }
        }
        if (j == text2.length()) {
            return i - j;
        } else {
            return -1;
        }
    }

    /**
     * 求next数组
     *
     * @param dest
     * @return
     */
    private static int[] kmpNext(String dest) {
        int[] next = new int[dest.length()];
        next[0] = 0;//模板字符串的第一个字符最大前后缀长度固定为0
        //for循环从第二个字符开始，依次计算每一个字符对应的next值
        for (int i = 1, j = 0; i < dest.length(); i++) {
            //递归求为最大的相同的前后缀长度
            while (j > 0 && dest.charAt(j) != dest.charAt(i)) {
                j = next[j - 1];
            }
            //如果相等，那么最大相同前后缀长度加1
            if (dest.charAt(i) == dest.charAt(j)) {
                j++;
            }
            next[i] = j;
        }
        return next;
    }

    /**
     * KMP算法
     *
     * @param str  文本串
     * @param dest 模式串
     * @param next
     * @return
     */
    private static int kmp(String str, String dest, int[] next) {
        for (int i = 0, j = 0; i < str.length(); i++) {
            while (j > 0 && str.charAt(i) != dest.charAt(j)) {
                j = next[j - 1];
            }
            if (str.charAt(i) == dest.charAt(j)) {
                j++;
            }
            if (j == dest.length()) {
                return i - j + 1;
            }
        }
        return 0;
    }
}

从头到尾彻底理解KMP
【经典算法】——KMP，深入讲解next数组的求解
下面是我的公众号，欢迎大家关注我