代码随想录算法训练营第八天| ● 344.反转字符串 ● 541. 反转字符串II ● 剑指Offer 05.替换空格 ● 151.翻转字符串里的单词 ● 剑指Offer58-II.左旋转字符串

leetcode 344

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

反转字符串

方法一：双指针

重点

不要用一个库函数reverse直接解决，但其中一个步骤用库函数是可以的

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s) - 1
        
        # 该方法已经不需要判断奇偶数，经测试后时间空间复杂度比用 for i in range(len(s)//2)更低
        # 因为while每次循环需要进行条件判断，而range函数不需要，直接生成数字，因此时间复杂度更低。推荐使用range
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
       

方法二：使用栈

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        stack = []
        for char in s:
            stack.append(char)
        for i in range(len(s)):
            s[i] = stack.pop()

方法三：使用range

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        n = len(s)
        for i in range(n // 2):
            s[i], s[n - i - 1] = s[n - i - 1], s[i]

方法四：使用reversed

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = reversed(s)

方法五：使用切片

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = s[::-1]

方法六：使用列表推导

完整python版答案

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = [s[i] for i in range(len(s) - 1, -1, -1)]

leetcode 541

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

反转字符串II

方法一：

重点

• 在遍历字符串的过程中，只要让i += (2 * k)，i 每次移动2 * k就可以了，然后判断是否需要有反转的区间。
• 因为要找的也就是每2 * k区间的起点，这样写，程序会高效很多。

完整python版答案

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """
        def reverse_substring(text):
            left, right = 0, len(text) - 1
            while left < right:
                text[left], text[right] = text[right], text[left]
                left += 1
                right -= 1
            return text
        
        res = list(s)

        for cur in range(0, len(s), 2 * k):
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)

方法二：

完整python版答案

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        # Two pointers. Another is inside the loop.
        p = 0
        while p < len(s):
            p2 = p + k
            # Written in this could be more pythonic.
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            p = p + 2 * k
        return s

leetcode 剑指Offer 05

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

替换空格

方法一：转换成列表，并且添加相匹配的空间，然后进行填充

• 因为字符串是不可变类型，所以操作字符串需要将其转换为列表，因此空间复杂度不可能为O(1)

重点

不使用额外空间的做法：
- 首先扩充数组到每个空格替换成"%20"之后的大小。
- 然后从后向前替换空格，也就是双指针法

完整python版答案

class Solution:
    def replaceSpace(self, s: str) -> str:
        counter = s.count(' ')
        
        res = list(s)
        # 每碰到一个空格就多拓展两个格子，1 + 2 = 3个位置存’%20‘
        res.extend([' '] * counter * 2)
        
        # 原始字符串的末尾，拓展后的末尾
        left, right = len(s) - 1, len(res) - 1
        
        while left >= 0:
            if res[left] != ' ':
                res[right] = res[left]
                right -= 1
            else:
                # [right - 2, right), 左闭右开
                res[right - 2: right + 1] = '%20'
                right -= 3
            left -= 1
        return ''.join(res)

方法二：添加空列表，添加匹配的结果

完整python版答案

class Solution:
    def replaceSpace(self, s: str) -> str:
        res = []
        for i in range(len(s)):
            if s[i] == ' ':
                res.append('%20')
            else:
                res.append(s[i])
        return ''.join(res)

方法三：使用切片

完整python版答案

class Solution:
    def replaceSpace(self, s: str) -> str:
        n = len(s)
        for e, i in enumerate(s[::-1]):
            print(i, e)
            if i == " ":
                s = s[: n - (e + 1)] + "%20" + s[n - e:]
            print("")
        return s

方法四：使用join + split

完整python版答案

class Solution:
    def replaceSpace(self, s: str) -> str:
        return "%20".join(s.split(" "))

方法五：使用replace

完整python版答案

class Solution:
    def replaceSpace(self, s: str) -> str:
        return s.replace(' ', '%20')

leetcode 151

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

翻转字符串里的单词

• 不要使用辅助空间，空间复杂度要求为O(1)。
• 将整个字符串都反转过来，那么单词的顺序就是倒序；那么再把单词反转一下，单词就正过来了。
• 思路：
  • 移除多余空格
  • 将整个字符串反转
  • 将每个单词反转
• 注意移除多余空格的时候用双指针法，一个指针遍历，另一个指针指向符合要求的字符

方法一：先删除空白，然后整个反转，最后单词反转

因为字符串是不可变类型，所以反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是O(1)

完整python版答案

class Solution:
    def reverseWords(self, s: str) -> str:
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

方法二：使用双指针

完整python版答案

class Solution:
    def reverseWords(self, s: str) -> str:
        # 将字符串拆分为单词，即转换成列表类型
        words = s.split()

        # 反转单词
        left, right = 0, len(words) - 1
        while left < right:
            words[left], words[right] = words[right], words[left]
            left += 1
            right -= 1

        # 将列表转换成字符串
        return " ".join(words)

leetcode 剑指Offer58-II

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

左旋转字符串

• 局部反转+整体反转
• 思路：
  • 反转区间为前n的子串
  • 反转区间为n到末尾的子串
  • 反转整个字符串

方法一：使用切片

完整python版答案

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        return s[n:] + s[:n]

方法二：使用reversed + join

完整python版答案

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        s = list(s)
        s[0:n] = list(reversed(s[0:n]))
        s[n:] = list(reversed(s[n:]))
        s.reverse()
        
        return "".join(s)

方法三：自定义reversed函数

完整python版答案

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:       
        s_list = list(s)
        
        self.reverse(s_list, 0, n - 1)        
        self.reverse(s_list, n, len(s_list) - 1)
        self.reverse(s_list, 0, len(s_list) - 1)

        return ''.join(s_list)
        
    def reverse(self, s, start, end):
        while start < end:
            s[start], s[end] = s[end], s[start]
            start += 1
            end -= 1   

方法四：使用 模 +下标

完整python版答案

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        new_s = ''
        for i in range(len(s)):
            j = (i+n)%len(s)
            new_s = new_s + s[j]
        return new_s

方法五：使用 模 + 切片

完整python版答案

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        l = len(s)
        # 复制输入字符串与它自己连接
        s = s + s
        
        # 计算旋转字符串的起始索引
        k = n % (l * 2)
        
        # 从连接的字符串中提取旋转后的字符串并返回
        return s[k : k + l]