代码随想录算法训练营day9｜28. 找出字符串中第一个匹配项的下标，459.重复的子字符串，字符串总结，双指针回顾

扭一扭.

已于 2022-12-04 15:31:18 修改

阅读量202

点赞数

文章标签：算法 leetcode 数据结构

于 2022-11-03 20:45:36 首次发布

本文链接：https://blog.csdn.net/weixin_52121600/article/details/127676722

版权

28. 找出字符串中第一个匹配项的下标

力扣

思路：KMP

【kmp算法】最长相等前后缀，用next[]数组储存。

1. j 指向前缀末尾位，也代表包括 i 之前的子串的最长相等前后缀的长度。i 指向后缀末尾位。

2. 初始化：j = 0; next[0] = 0; i =1 ;

3. 循环不变量：遇见冲突看前一位。当前后缀不相等时，j 回退到下标为它的前一位的值的位置。当前后缀相等时，j后移，更新next数组的值。

注意：needle字符串作为模式串，因此是要获得needle字符串的next数组；

class Solution {
    public int strStr(String haystack, String needle) {
        if(needle.length()==0) return 0;
        if(needle.length()>haystack.length()) return -1;
        int[] next = getNext(needle);//获得模式串的前缀表
        for(int i=0,j=0;i<haystack.length();i++){
            while(j>0 && needle.charAt(j)!=haystack.charAt(i)){
                j=next[j-1];//j回退
            }
            if(needle.charAt(j)==haystack.charAt(i)){
                if(j==needle.length()-1){//匹配结束，返回i-j
                    return i-j;
                }
                j++;
            }
        }
        return -1;
    }
    public int[] getNext(String s){
        int[] next = new int[s.length()];
        for(int i=1,j=0;i<s.length();i++){
            while(j>0 && s.charAt(i)!=s.charAt(j)){//字符不匹配
                j=next[j-1];
            }
            if(s.charAt(i)==s.charAt(j)){//字符相匹配
                j++;
            }
            next[i]=j;//更新next[]
        }
        return next;
    }
}

思路：基于滑动窗口的算法

1. 利用两个指针，找到文本串中第一个相匹配的字符后，依次匹配；

2. 每次遇到字符不相同的情况，文本串的查找起始位置向右移动一位，模式串从头开始；

class Solution {
    public int strStr(String haystack, String needle) {
        int n=needle.length(),h=haystack.length();
        if(n==0) return 0;
        if(n>h) return -1;
        int i=0,j=0;
        while(i<h-n+1){//haystack中第一个匹配的字符下标一定<h-n+1
            while(i<h && haystack.charAt(i)!=needle.charAt(j)){
                i++;
                if(i==h-n+1) return -1;
            }
            while(i<h && j<n && haystack.charAt(i)==needle.charAt(j)){
                i++;
                j++;
            }
            if(j==n) return i-j;
            i-=j-1;//-1:i需要回退后向右移动一步
            j=0;
        }
        return -1;
    }
}

459.重复的子字符串

力扣

思路：

【kmp算法】

1. 在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串。如图，s[0]s[1] = t[0]t[1] = k[0]k[1] = t[2]t[3] = s[2]s[3]；s[0]s[1] 一定是最小重复子串。

「数组长度」-「最长相同前后缀的长度」=「一个周期的长度」

2.假设字符串s由多个重复子串（最小重复单位，长度x）构成，则s.length()=n*x；由于s的最长相同前后缀一定不包含s本身，所以最长相同前后缀长度必然是m*x，且 n-m=1。

3. 那么如果len % (len - (next[len - 1] + 1)) == 0 ，就说明该字符串有重复子字符串。「一个周期的长度」可以被「字符串长度」整除，则说明字符串由重复子串组成。

【注意】next[len-1] 若为0，则说明没有相同前后缀，返回false；

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        int[] next = getNext(s);//得到next[]
        int len = s.length();
        int sub = len-next[len-1];//[一个周期的长度]
        if(next[len-1]>0 && len%sub==0) return true;
        return false;
    }
    public int[] getNext(String s){
        int[] next = new int[s.length()];
        for(int i=1,j=0;i<s.length();i++){
            while(j>0 && s.charAt(i)!=s.charAt(j)){
                j=next[j-1];
            }
            if(s.charAt(i)==s.charAt(j)){
                j++;
            }
            next[i]=j;
        }
        return next;
    }
}