KMP-Java

1.KMP简介

        KMP算法（Knuth-Morris-Pratt算法）是一种用于高效地解决字符串匹配问题的算法。该算法的核心思想是通过预处理模式串（要匹配的字符串）构建一个回退表（也称为部分匹配表），以在匹配过程中避免不必要的回溯。

        KMP算法的优势在于在匹配过程中，不需要回溯到文本串中之前已经比较过的位置，因此可以避免重复比较，提高匹配效率。它的核心是根据模式串构建一个回退表（部分匹配表），该表记录了模式串每个位置匹配失败时应该回退到的位置。

        KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。

        KMP算法的时间复杂度为O(n+m)，其中n是文本串的长度，m是模式串的长度。

        KMP算法在字符串匹配、子串查找、相似度计算等问题中有广泛应用，它的高效性和优越性使得它成为字符串处理的常用算法之一

2.BF(Brute Force)算法

前置条件

有两个字符串str1和str2，求str2是否是str1的子串（需连续），若是字串则返回str1中的下标,不存在返回-1.

例1. str1 ="abcd"   str2 = "abcd"  返回0

例2. str1 ="abcd"   str2 = "html"  返回-1

例3. str1 ="abcde"   str2 = "cde"  返回2

public static int strStr1(String str1, String str2) {
        if (Objects.equals(str1, "") && Objects.equals(str2, "")) {
            return 0;
        }
        if (str1 == null || str2 == null || str1.length() < str2.length()) {
            return -1;
        }
        char[] chars1 = str1.toCharArray();
        char[] chars2 = str2.toCharArray();
        for (int i = 0; i < chars1.length; i++) {
            int count = i;
            for (int j = 0; j < chars2.length; j++) {
                while (i < chars1.length && j < chars2.length && chars1[i] == chars2[j]) {
                    i++;
                    j++;
                }
                if (j == chars2.length) {
                    return i - j;
                } else {
                    i = count;
                    break;
                }
            }
        }
        return -1;
    }

3.KMP算法 

        思路：当我们发现某一个字符不匹配的时候，由于已经知道之前遍历过的字符，那能不能利用这些信息来避免暴力算法中"回退（backup）"的步骤呢？即主串中的指针一直向前移动。 KMP算法在匹配失败的时候，会去看最后一个匹配的字符它所对应的next数值，于是移动子串，直接跳过对应子串的字符

        与BF的区别：不再回退主串中的指针，只需要遍历一次主串即可

        KMP算法是在暴力算法的基础上使用的算法，就是使用了next数组进行加速，KMP的加速过程--核心next数组的生成，next数组的生成只需要模式串即可，不需要子串，那么什么是next数组？

        next数组代表了在匹配失败的时候，子串中可以跳过的匹配个数。其本质其实就是寻找子串中相同前后缀的长度【并且一定是最长的】，前后缀不能是字符串本身。

        next数组的求解，采用递推公式快速求解next数组【原因就是比BF更快】：巧妙之处，不断利用已经掌握的信息避免重复的计算

        next数组的第一个元素为0，因为一个元素不存在前后缀。

        假设我们已经知道当前的共同前后缀了，分两种情况讨论：
       1.如果下一个字符依然相同的话，那么不就构成了一个更长的前后缀吗，很明显他的长的=之前的加上1
       2.下一个字符不同，我们就看看其中存不存在更短的，其实可能与下一个字符构成共同的前后缀的，这一步难道要暴力求解吗?
     其实不同，根据之前的计算我们掌握了一个重要信息，就是子串前后这两部分是完全相同的，也就是说，右边这部分的后缀其实等于左边这部分的后缀
     那么直接在左边寻找共同的前后缀即可，而左边的前后缀之前已经计算过了，直接查表即可知道它的长度为1，于是我们又回到了最开始的步骤，检查下一个字符是否相同

public static int strStr(String str1, String str2) {
        if (Objects.equals(str1, "") && Objects.equals(str2, "")) {
            return 0;
        }
        if (str1 == null || str2 == null || str1.length() < str2.length()) {
            return -1;
        }
        char[] chars1 = str1.toCharArray();
        char[] chars2 = str2.toCharArray();
        int i = 0;//主串中的指针
        int j = 0;//子串中的指针
        while (i < chars1.length) {
            int[] nextArray = getNextArray(chars2);
            if (j < chars1.length && chars1[i] == chars2[j]) {//两字符相同
                i++;
                j++;
            } else if (j > 0) {//两字符不相同
                j = nextArray[j - 1];//如果不相同，则根据next数值跳过子串前几个字符的比较
            } else {//子串第一个字符就匹配失败
                i++;
            }
            if (j == chars2.length) {//匹配成功
                return i - j;
            }
        }
        return -1;
    }
    public static int[] getNextArray(char[] chars) {
        int[] next = new int[chars.length];
        next[0] = 0;
        int i = 1;
        int prefix = 0;//当前共同前后缀长度
        while (i < chars.length) {
            if (chars[prefix] == chars[i]) {//下一个字符相同的话,代表可可以构成一个更长的前后缀
                prefix += 1;
                next[i] = prefix;
                i++;
            } else {//下一个字符不同
                if (prefix == 0) {//如果依然不存在的话，那么设为0即可
                    next[i] = 0;
                    i++;
                } else {
                    //直接查表看看存不存在更短的前后缀,
                    prefix = next[prefix - 1];
                }
            }
        }
        return next;
    }

此方法来自于B站：最浅显易懂的 KMP 算法讲解_哔哩哔哩_bilibili