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

今日任务

● 344.反转字符串
● 541. 反转字符串II
● 剑指Offer 05.替换空格
● 151.翻转字符串里的单词
● 剑指Offer58-II.左旋转字符串

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/reverse-string

如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数
如果库函数仅仅是 解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。

在反转链表中，使用了双指针的方法。
那么反转字符串依然是使用双指针的方法，只不过对于字符串的反转，其实要比链表简单一些。
因为字符串也是一种数组，所以元素在内存中是连续分布，这就决定了反转链表和反转字符串方式上还是有所差异的。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        # s.reverse()  # 库函数，就地修改
        # reversed(s) # 内建函数，返回新的逆序排列的数组
        left, right = 0, len(s)-1
        while left < right:  # 不用判断奇偶，奇数中间的数还是在中间，此时left=right
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1

541. 反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:

输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/reverse-string-ii

• leetcode的题不看示例，我真的读不懂

法一

法二

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])
        	# 切片 ：当切片时，是对原始列表、字符串进行切片复制，超出范围，则为空，不会报错
        	# 这个特性可以保证剩余字符串不足k个时仍可以反转
        return ''.join(res)  # 列表转为字符串

切片这里学到了，以前真没注意

剑指Offer 05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

法一：（自己想的）

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

法二：双指针

class Solution:
    def replaceSpace(self, s: str) -> str:
        count = 0
        for i in s:
            if i == ' ':
                count += 1
        # count = s.count(' ')
        res = list(s)
        # 每遇到一个空格都扩充两个位置，1 + 2 = 3 用来存放 %20
        res.extend([' '] * count * 2)
        # 原始字符串的结尾，拓展后的末尾
        l, r = len(s)-1, len(res)-1
        while l >= 0:
            if res[l] != ' ':
                res[r] = res[l]
                r -= 1
            else:
                # [right - 2, right), 左闭右开
                res[r - 2: r + 1] = '%20'
                r -= 3
            l -= 1
        return ''.join(res)

法三和法四

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

        # method 2 - Reverse the s when counting in for loop, then update from the end.
        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

151.翻转字符串里的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/reverse-words-in-a-string

法一（自己想的）

class Solution:
    def reverseWords(self, s: str) -> str:
        res = s.split(' ')
        # print(res[0]=='')
        i = 0
        while i < len(res): # 删除多余空格导致的数组多余元素
            if res[i] == '':
                res.pop(i)
            else:
                i += 1
        # print(res)
        return ' '.join(res[::-1])
# method II: simpler     
class Solution:
    def reverseWords(self, s: str) -> str:
        res = [i for i in s.split(' ') if len(i) > 0]
        return ' '.join(res[::-1])

不要使用辅助空间，空间复杂度要求为O(1)。
法二：
解题思路如下：

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

使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。

剑指Offer58-II.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof

法一（自己想的）

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = list(s)
        m = len(res)-n
        res[:m], res[m:] = res[n:], res[:n]
        return ''.join(res)