代码随想录算法训练营第九天｜151.翻转字符串里的单词卡码网：55.右旋转字符串 28. 实现 strStr() 459.重复的子字符串

最新推荐文章于 2024-07-25 22:42:34 发布

PixcelPrincess

最新推荐文章于 2024-07-25 22:42:34 发布

阅读量518

点赞数 5

文章标签：算法

本文链接：https://blog.csdn.net/qq_39981702/article/details/140687716

版权

写在前边的话

今天是字符串训练的第二天，由于刷过28，459知道又到了死磕KMP的时候了，回想了一下发现自己还是不熟！！！

151.翻转字符串里的单词

题目链接

力扣151.翻转字符串里的单词

题目难度

中等

看到题目的第一想法

有了昨天题目的训练今天看到题目的第一想法就是将字符串以空格进行分割成数组（split的时间复杂度是O(n)），然后再利用双指针进行翻转。但是看完卡哥的讲解说这样的写法这个题目就成了一个水题，并且失去了它的意义！！！但是看了卡哥的思路，由于python和java中字符串均是不可变的，所以无论是python中转换成列表的操作，或者java中转换成StringBuilder(可变对对象)的操作都是需要O(n)的空间复杂度的。

看完代码随想录总结

解题思路

注意：不要使用辅助空间，空间复杂度要求为O(1)，但是python和java都没法做到。

卡哥思路（暂时没使用这种思路解题，等着后边如果二刷的话再来看这种思路的代码编写吧）

移除多余空格
将整个字符串反转
将每个单词反转

我的思路

使用split进行分割字符串
使用双指针进行翻转

文章讲解

代码随想录151. 翻转字符串里的单词文章讲解

视频讲解

代码随想录151. 翻转字符串里的单词视频讲解

代码编写

python

class Solution:
    def reverseWords(self, s: str) -> str:
        s_list = s.strip().split()
        left = 0
        right = len(s_list) - 1
        while(left < right):
            s_list[left], s_list[right] = s_list[right], s_list[left]
            left += 1
            right -= 1
        return ' '.join(s_list)

时间复杂度：O(n)
空间复杂度：O(n)

java

class Solution {
    public String reverseWords(String s) {
        String[] str = s.trim().split("\\s+");
        int left = 0;
        int right = str.length - 1;
        while(left < right){
            String tmp = str[right];
            str[right] = str[left];
            str[left] = tmp;
            left++;
            right--;
        }
        String res = String.join(" ", str);
        return res;
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

卡码网：55.右旋转字符串

题目链接

卡码网55. 右旋转字符串

看到题目的第一想法

看到题目时，python想到了切片获取两部分数据然后+；java想到了卡哥上边一个题目的翻转思想。

看完代码随想录总结

解题思路

1. python直接切片获取两部分

2. java 先转char[]，再整个数组翻转，最后前后两部分分别翻转（翻转方法使用的是双指针）。

文章讲解

代码随想录55.右旋转字符串文章讲解

代码编写

python

k = int(input())
s = input()
print(s[-k:]+s[0:-k])

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

java

import java.util.Scanner;

public class Main{
    public static void reverse(char[] ch, int left, int right) {
        while(left < right){
            char tmp = ch[right];
            ch[right] = ch[left];
            ch[left] = tmp;
            left++;
            right--;
        }
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = Integer.parseInt(scanner.nextLine());
        String s = scanner.nextLine();
        
        int len = s.length();
        char[] ch = s.toCharArray();
        reverse(ch, 0, len-1); //翻转整个字符串
        reverse(ch, 0, k-1); //翻转前部分
        reverse(ch, k, len-1); //翻转后部分
        
        System.out.println(ch);
    }
    
}

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

28. 实现 strStr()

题目链接

力扣 28. 实现strStr()

题目难度

简单

看到题目的第一想法

第一想法是使用暴力比较的方法，循环haystack字符串，并比较当前位置到与needle等长的字符串是否与needle相等。

python

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        m = len(haystack)
        n = len(needle)
        if m < n:
            return -1

        for i in range(m):
            if haystack[i:i+n] == needle:
                return i

        return -1

时间复杂度：O(m*n)
空间复杂度：O(1)

看完代码随想录总结

解题思路

1. KMP算法：主要用在字符串匹配场景，可以避免从头开始匹配。

2. 找到的不匹配的位置，看它的前一个字符的前缀表的数值是多少，再从这个位置开始匹配。

文章讲解

代码随想录28. 实现 strStr()文章讲解

视频讲解

KMP

求解next数组

代码编写

python next数组是不减1的情况

class Solution(object):
    def getNext(self, s, nxt):
        j = 0  # 要跳转到的下一个要比较的位置
        nxt[0] = 0
        for i in range(1, len(s)): 
            while j > 0 and s[i] != s[j]:   # 如果不相等则跳转到前一个位置要跳转的地方，并比较是否相等，不相等的话继续往前跳
                j = nxt[j-1]
            if s[i] == s[j]:  # 相等的话则相等前后缀就会加1要跳转的位置也加1
                j += 1
            nxt[i] = j  # 找到j以后即找到当前位置的最长相等前后缀，赋值给next数组
            
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        m = len(haystack)
        n = len(needle)
        if m < n:
            return -1

        needle_nxt = [0]*len(needle)
        j = 0
        self.getNext(needle, needle_nxt)
        for i in range(m):
            while j > 0 and  haystack[i] != needle[j]:
                j = needle_nxt[j - 1]
            if haystack[i] == needle[j]:
                j += 1
            if j == len(needle):
                return i - j + 1
        return -1

时间复杂度：O(m+n)
空间复杂度：O(n)

java

class Solution {
    public void getNext(String s, int[] next){
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < next.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;
        }
    }
    public int strStr(String haystack, String needle) {
        int m = haystack.length();
        int n = needle.length();

        int[] next = new int[n];
        getNext(needle, next);
        int j = 0;
        for(int i = 0; i < m; i++){
            while(j > 0 && haystack.charAt(i) != needle.charAt(j)){
                j = next[j - 1];
            }
            if(haystack.charAt(i) == needle.charAt(j)){
                j++;
            }
            if(j == n){
                return i-j+1;
            }
        }
        return -1;
    }
}

时间复杂度：O(m+n)
空间复杂度：O(n)

459.重复的子字符串

题目链接

力扣459. 重复的子字符串

题目难度

简单

看到题目的第一想法

第一眼看到整个题目的时候会想到用暴力法。

python

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n <=1 :
            return False
        for i in range(1, n//2 + 1):
            if n % i == 0:
                l = s[:i]
                if l * (n//i) == s:
                    return True
        return False

时间复杂度：O(n^2)
空间复杂度：O(n)

看完代码随想录总结

解题思路

1. KMP

结论：1）如果字符串有重复的子串，那么字符串的最长相等前后缀不包含的子串就是最小重复子串

2) 找到最长前后缀并计算大小，如果数组长度取余（数组长度减最长前后缀）为0的话，则说明存在重复子串。

文章讲解

代码随想录459.重复的子字符串文章讲解

视频讲解

代码随想录459.重复的子字符串视频讲解

代码编写

python

class Solution:
    def getNext(self, s, nxt):
        j = 0
        for i in range(1, len(s)):
            while(j > 0 and s[i] != s[j]):
                j = nxt[j - 1]
            if s[i] == s[j]:
                j += 1
            nxt[i] = j
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n == 1:
            return False
        nxt = [0] * n
        self.getNext(s, nxt)
        if nxt[-1]!= 0 and n % (n - nxt[-1]) == 0:
            return True
        return False

时间复杂度：O(n)
空间复杂度：O(n)

java

class Solution {
    public static void getNext(String s, int[] next){
        int n = s.length();
        next[0] = 0;
        int j = 0;
        for(int i=1; i<n; 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;
        }
    }
    public boolean repeatedSubstringPattern(String s) {
        int n = s.length();
        int[] next = new int[n];
        getNext(s, next);
        if(next[n-1]>0 && n % (n - next[n-1]) == 0){
            return true;
        }
        return false;   
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

今日总结

151和55是翻转字符串的升级版，对于双指针的使用更加熟悉了；28、459是KMP算法的应用，主要是next数组的计算，感觉不减1的方法更好理解一点，因此代码的编写都是用的这种写法。感觉KMP还是不是特别熟悉，现在是自己可以写了，不知道过一段时间会怎么样，周末再来回顾下吧。

PixcelPrincess

关注

5
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第九天｜151.翻转字符串里的单词卡码网：55.右旋转字符串 28. 实现 strStr() 459.重复的子字符串

不要使用辅助空间，空间复杂度要求为O(1)，但是python和java都没法做到。卡哥思路（暂时没使用这种思路解题，等着后边如果二刷的话再来看这种思路的代码编写吧）移除多余空格将整个字符串反转将每个单词反转我的思路使用split进行分割字符串使用双指针进行翻转1. python直接切片获取两部分2. java 先转char[]，再整个数组翻转，最后前后两部分分别翻转（翻转方法使用的是双指针）。1. KMP算法：主要用在字符串匹配场景，可以避免从头开始匹配。
复制链接

扫一扫

代码随想录算法训练营第九天｜151.翻转字符串里的单词 卡码网：55.右旋转字符串 28. 实现 strStr() 459.重复的子字符串

写在前边的话

151.翻转字符串里的单词

题目链接

题目难度

看到题目的第一想法

看完代码随想录总结

解题思路

文章讲解

视频讲解

代码编写

卡码网：55.右旋转字符串

题目链接

看到题目的第一想法

看完代码随想录总结

解题思路

文章讲解

代码编写

28. 实现 strStr()

题目链接

题目难度

看到题目的第一想法

看完代码随想录总结

解题思路

文章讲解

视频讲解

代码编写

459.重复的子字符串

题目链接

题目难度

看到题目的第一想法

看完代码随想录总结

解题思路

文章讲解

视频讲解

代码编写

今日总结

代码随想录算法训练营第九天｜151.翻转字符串里的单词卡码网：55.右旋转字符串 28. 实现 strStr() 459.重复的子字符串