代码随想录算法训练营第九天（字符串II）| 28. 实现 strStr()、459. 重复的子字符串(JAVA)-CSDN博客

本文链接：https://blog.csdn.net/m0_61634066/article/details/136702144

文章目录

28. 实现 strStr()
- 解题思路
- 源码
459. 重复的子字符串
- 解题思路
- 源码
总结

28. 实现 strStr()

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

示例 1：

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

示例 2：

输入：haystack = “leetcode”, needle = “leeto”
输出：-1
解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1 。

提示：

1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

解题思路

KMP算法求解字符串匹配问题，关键为next数组表示前缀表，使得不匹配时根据前缀表实现部分回退。next数组的构造要好好研究，很重要！！

源码

class Solution {
    public int strStr(String haystack, String needle) {
        int i=1; 
        int j=-1;
        int[] next = new int[needle.length()];
        // 模式串赋值
        next[0]=-1;
        for(i=1; i<needle.length(); i++){
            // 前后缀不相等，回退
            while(j>=0 && needle.charAt(j+1)!=needle.charAt(i)){
                j=next[j];
            }
            // 前后缀相等
            if(needle.charAt(j+1) == needle.charAt(i)){
                j++;
            }
            next[i]=j;
        }
        //匹配
        j=-1;
        for(i=0; i<haystack.length(); i++){
            while(j>=0 && haystack.charAt(i)!=needle.charAt(j+1)){
                j=next[j];
            }
            if(haystack.charAt(i)==needle.charAt(j+1)){
                j++;
            }
            if(j==needle.length()-1){
                return i-needle.length()+1;
            }
        }
        return -1;
    }
}

时间复杂度: O(n + m)
空间复杂度: O(m) 只需要保存字符串needle的前缀表

459. 重复的子字符串

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

示例 1:

输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

示例 2:

输入: s = “aba”
输出: false

示例 3:

输入: s = “abcabcabcabc”
输出: true
解释: 可由子串 “abc” 重复四次构成。 (或子串 “abcabc” 重复两次构成。)

提示：

1 <= s.length <= 104
s 由小写英文字母组成

解题思路

既可以用移动匹配也可以用KMP，移动匹配的思路真的好绝！
假如字符串s是由子串构成的，那么s+s在删去头尾两个字符后一定能在中间搜索到s

源码

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        // 移动匹配
        String ss = new String(s+s);
        int i, j=0;
        for(i=1; i<ss.length()-1; i++){
            while(ss.charAt(i)==s.charAt(j) && i<ss.length()-1){
                i++;
                j++;
                if(j==s.length()){
                    return true;
                }
            }
            i-=j;
            j=0;
        }
        return false;
    }
}

时间复杂度: O(n)
空间复杂度: O(1)

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;
		// KMP
        int len = s.length();
        // 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了
        s = " " + s;
        char[] chars = s.toCharArray();
        int[] next = new int[len + 1];
        // 构造 next 数组过程，j从0开始(空格)，i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功，j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功，j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }
        // 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }
}