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

数组基础知识

数组的元素是不能删的，只能覆盖。

那么二维数组直接上图，大家应该就知道怎么回事了

  

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

提示：

• 1 <= s.length <= 105
• s[i] 都是 ASCII 码表中的可打印字符

双指针经典移动过程：从两边向中间移动。

对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。

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

        left = 0
        right = len(s) - 1

        while left < right:
            temp = s[left]
            s[left] = s[right]
            s[right] = temp

            left += 1
            right -= 1



        # # 方法二
        # """
        # 题目期望直接在原字符串上进行修改，而不是返回一个新的反转字符串。
        # 因此我们使用s[:] = s[::-1]而不是s = s[::-1]。
        # """
        # s[:] = s[::-1]
        

541. 反转字符串 II

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

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

示例 1：

输入：s = "abcdefg", k = 2
输出："bacdfeg"

示例 2：

输入：s = "abcd", k = 2
输出："bacd"

提示：

• 1 <= s.length <= 104
• s 仅由小写英文组成
• 1 <= k <= 104

其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。

因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。

tips: Python 的切片操作允许索引超出列表的长度，当结束索引超出列表长度时，它将只取到列表的最后一个元素。

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """

        def reverseSubstring(substr_list):
            left = 0
            right = len(substr_list) - 1

            while left < right:
                temp = substr_list[left]
                substr_list[left] = substr_list[right]
                substr_list[right] = temp
                left += 1
                right -= 1

            return substr_list
        
        s = list(s)

        for i in range(0,len(s),2*k):
            s[i : i+k] = reverseSubstring(s[i : i+k])

        return "".join(s)

剑指 Offer 05. 替换空格

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

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

限制：

0 <= s 的长度 <= 10000

方法一： 使用内置函数 

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """

        # 方法一
        """
        时间复杂度：replace() 函数在最坏的情况下需要遍历整个字符串一次，
        因此时间复杂度是 O(n)，其中 n 是字符串的长度。

        空间复杂度：replace() 函数返回一个新的字符串，因为字符串在 Python 中是不可变的，
        所以它需要分配足够的空间来存储新的字符串。在最坏的情况下，即字符串中的每个字符都是
        空格，需要的空间是原始字符串的三倍，因此空间复杂度是 O(n)，其中 n 是字符串的长度。

        需要注意的是，这种分析是基于 Python 的特定实现的。在某些其他语言中，
        例如 Java，字符串可能是可变的，所以空间复杂度可能会有所不同
        """
        return s.replace(" ", "%20")
        

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

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """

        # 方法二
        """
        time: O(n) 
        space: O(n) 
        """
        res = []
        for i in s:
            if i == " ":
                res.append("%20")
            else:
                res.append(i)
        return "".join(res)

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

提示：

• 1 <= s.length <= 104
• s 包含英文大小写字母、数字和空格 ' '
• s 中 至少存在一个 单词

进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。

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

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        time:  O(n)
        space:  O(n)
        虽然方法二中使用了“原地”反转单词列表的操作（不需要额外的存储空间），
        但在 Python 中，字符串是不可变的，因此需要创建新的字符串来存储结果，
        所以总的空间复杂度仍然是 O(n)。
        """

        # # 方法一
        # my_list = s.split()
        # reverse_my_list = my_list[::-1]

        # return " ".join(reverse_my_list)

        # 方法二
        my_list = s.split()

        left = 0
        right = len(my_list) - 1

        while left < right:
            my_list[left], my_list[right] = my_list[right], my_list[left]
            left += 1
            right -= 1
        return " ".join(my_list)

剑指 Offer 58 - II. 左旋转字符串

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

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

限制：

• 1 <= k < s.length <= 10000

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        time: O(n)
        space: O(n)
        切片操作需要 O(n) 的时间和空间，而字符串的拼接也需要 O(n) 的时间和空间。
        """

        return "".join([s[n:], s[:n]])