代码随想录Day_9打卡

①、找出字符串中第一个匹配的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

力扣（LeetCode）链接：https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string

事例：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0

        一、暴力迭代

public int strStr(String haystack,String needle){
    if(haystack == null || needle == null || haystack.length() < needle.length()){
        return -1;
    }
    int i = 0;
    int j = 0;
    while(i < haystack.length()){
        if(haystack[i] == needle[j]){
            i++;
            j++;
        }else {
            i = i - j + 1;
        }
        if(j == needle.length()) return j;
    }
    return -1;
}

        二、KMP算法

代码：

public int strStr(String haystack, String needle) {
        int[] next = kmpNext(needle);
        char[] arr1 = haystack.toCharArray();
        char[] arr2 = needle.toCharArray();
        int i = 0;
        int j = 0;
        while(i < arr1.length){
            if(arr1[i] == arr2[j]){
                j++;
                i++;
            }else if(j > 0){
                j = next[j - 1];
            }else{
                i++;
            }
            if(j == arr2.length){
                return i - j;
            }
        }
        return -1;
    }

    public int[] kmpNext(String s){
        int[] next = new int[s.length()];
        int ll = 0;
        next[0] = 0;
        char[] arr = s.toCharArray();
        for(int i = 1;i < next.length;i++){
            //回退
            while(ll > 0 && arr[ll] != arr[i]){
                ll = next[ll - 1];
            }
            if(arr[ll] == arr[i]){
                ll++;
                next[i] = ll;
            }else{
                next[i] = ll;
            }
        }
        return next;
    }

简单讲解：

        KMP是一种用于字符串匹配的高效算法，能将暴力迭代中O(m * n)的时间复杂度降为O(m + n)，其中与暴力迭代不同是，借助了next数组，每次遇到不同的字符时回退到最大前后缀相同的位置重新匹配。

        next数组:存放了每个字符对应的最大前后缀相同数

        前缀：包含首字符且没有尾字符的子串

        后缀：包含尾字符且没有首字符的子串

next数组的求解：

求一个字符串的next数组，其实就是让这个字符串中每个字符匹配自己的最大前后缀数。

 以上图数组为例，在kmpNext方法中，用变量ll标记最大前后缀数后面的位置(同时值也为当前字串的最大前后缀数)，在第一个字符a时，没有前后缀，next[0] = 0（固定的），到第二个字符时，前后缀都是a，此时最大前后缀数等于1(ll++)，next[1] = 1，"aab" 前后缀不同，此时ll不再代表最大前后缀数，需要回退到0或者前后缀开始匹配的位置。就这样一直遍历完字符串，将next数组赋值。

next数组存放的是当前字符串最大前后缀数，故当字符串匹配不上时，可以直接回退为next[j - 1]，j代表匹配到的needle字符串索引。 

②、重复的子字符串

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

事例：
输入: s = "abcabcabcabc"
输出: true

力扣（LeetCode）链接：https://leetcode.cn/problems/repeated-substring-pattern

做法：

       

以上图字符串为例，s是符合题目的字符串，t k分别是s最后一个字符的最长前后缀数对应的两个字符串，故可以得到 t[0] = k[0] t[1] = k[1] ... t[4] = k[4] t[5] = k[5]，由于t[0] = k[0]，t[1] = k[1] 故s[2] = k[0] s[3] = k[1] ，从而得到s[0] = s[2] s[1] = s[3]，依次重复，可得s是由s[0] s[1]重复而成的字符串。

因此得出：重复的字符串剔除最后字符的最长前后缀数的字符串，剩余的字串就是最小重复单位。

若是最后字符的最长前后缀数的字符串中间有空格(字符)时，则说明匹配到最后一轮(上图的k字符串)时，会有字符没被匹配进去。

故重复的字符串满足 len % (len - next[len - 1]) == 0

代码：

public boolean repeatedSubstringPattern(String s) {
        int[] next = kmpNext(s);
        int n = s.length();
        if(next[n - 1] != 0 && (n % (n - next[n - 1]) == 0)) return true;
        return false;
    }

    public int[] kmpNext(String s){
        int[] next = new int[s.length()];
        int ll = 0;
        next[0] = 0;
        char[] arr = s.toCharArray();
        for(int i = 1;i < next.length;i++){
            //回退
            while(ll > 0 && arr[ll] != arr[i]){
                ll = next[ll - 1];
            }
            if(arr[ll] == arr[i]){
                ll++;
                next[i] = ll;
            }else{
                next[i] = ll;
            }
        }
        return next;
    }

 参考文献：代码随想录 (programmercarl.com)