关于 KMP 算法的个人理解(附 Java 实现代码)

为什么会提出 KMP 算法

为了解决传统的朴素算法匹配字符串的低效

为什么朴素算法会低效

传统的朴素算法在匹配字符串失败的时候，主串和模式串都要回溯，主串回溯到匹配起始位置加1， 模式串回溯到第一个字符，从头开始匹配，这样会产生很多不必要的回溯，所以朴素算法低效。时间复杂度为O( (n - m +1）* m），即O（n * m）。

KMP 算法的思想

既然朴素算法会产生不必要的回溯，那么就要想办法消除这些不必要的回溯，首先当匹配失败的时候，主串不可以回溯，然后通过修改模式串的当前指针指向的位置，让其尽量移动到有效的位置。那么怎么才能得到这个有效的位置呢我们可以通过分析模式串的自身结构，判断其自身前后是否有重复的子串，然后根据最长重复子串的长度（即模式串前缀和后缀交集的长度）来决定模式串回溯的位置。然后通过一个 next 数组来保存这些信息，所以重点是求出这个 next 数组。

怎么求得 next 数组

• 令 next 【0】= 0；
• 然后遍历模式串，令 i 指针始终指向 后缀字符串的最后一个字符，j 指针始终指向前缀字符串的第一个字符。
• 判断 i 和 j 指向的字符是否相等，如果相等，则next【i】= j，同时 指针 i 和 j 均后移一位，如果不相等，则让 j 指针不断回溯，直到 i 和 j 指向的字符相等或者 j 指向模式串的第一个位置。
• 遍历完模式串后，即可以得到 next 数组。

KMP 算法的时间复杂度为O（n + m），空间复杂度为O（m），其中 n 是主串长度，m 是 模式串长度

Java 代码实现

package com.wuyi.notecode;

public class KMP {

    private int[] next;

    public int KMP(String T, String P){
        // 先构造 next 数组
        createNext(P);

        for(int i = 0, j = 0; i < T.length();){
            if (j == P.length() - 1)
                return i - j;

            if (j == 0 || T.charAt(i) == P.charAt(j)){
                i++;
                j++;
            } else {
                j = next[j];
            }
        }
        return -1;
    }

    private void createNext(String P) {
        next = new int[P.length()];
        next[0] = 0;

        for (int i = 1, j = 0;i < P.length();){
            if (j == 0 || P.charAt(i - 1) == P.charAt(j - 1)){
                //j - 1 代表前缀的最后一个索引，i - 1 代表后缀的最后一个索引
                next[i] = j;
                i++;
                j++;
            } else {
                // 若字符不相等，则 j 值回溯
                j = next[j];
            }
        }
    }

    public static void main(String[] args) {
        KMP kmp = new KMP();
        int res = kmp.KMP("baabcabxaababaaabaab","ababaaaba");
        for (int a : kmp.next){
            System.out.print(a + " ");
        }
        System.out.println("\nres:" + res);
    }
}

KMP 算法的改进

其实原始的 KMP 算法还是存在缺陷的，比如模式串存在连续多位相等的字符时，需要通过多次回溯才能来到有效的匹配位置，那么我们可以将其改进为通过一次回溯就来到有效的匹配位置。

在计算 next 值的同时，如果 a 字符与 next [i] 值指向的 b字符相等，则该 a 的 next [i] 就指向 b 的 next [i] 值，如果不等，则该 a 的 next [i] 值就是它自己的 next [i] 值。

package com.wuyi.notecode;

public class KMP {

    private int[] next;

    public int KMP(String T, String P){
        // 先构造 next 数组
        createNext(P);

        for(int i = 0, j = 0; i < T.length();){
            if (j == P.length() - 1)
                return i - j;

            if (j == 0 || T.charAt(i) == P.charAt(j)){
                i++;
                j++;
            } else {
                j = next[j];
            }
        }
        return -1;
    }

    private void createNext(String P) {
        next = new int[P.length()];
        next[0] = 0;

        for (int i = 1, j = 0;i < P.length();){
            if (j == 0 || P.charAt(i - 1) == P.charAt(j - 1)){
                //j - 1 代表前缀的最后一个索引，i - 1 代表后缀的最后一个索引
                //next[i] = j;
                if (P.charAt(i) != P.charAt(j))
                    next[i] = j;
                else
                    next[i] = next[j];
                i++;
                j++;
            } else {
                // 若字符不相等，则 j 值回溯
                j = next[j];
            }
        }
    }

    public static void main(String[] args) {
        KMP kmp = new KMP();
        int res = kmp.KMP("baabcabxaababaaabaab","abaaba");
        for (int a : kmp.next){
            System.out.print(a + " ");
        }
        System.out.println("\nres:" + res);
    }
}