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

---

Leetcode 344.反转字符串

双指针

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

---

Leetcode 541. 反转字符串II

这题按照题目的意思写出了第一段代码，也能通过，但是隐约觉得似乎处理复杂了。看了解答后才想通，其实只用一个指针去作为每个2k长度区间的起点，判断当这个指针没有超过字符串数组长度时，对接下来k个字符or剩下的不足k个字符去进行翻转就好了，对应着第二段代码。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        def reverseFunction(l: int, r: int, w:list) -> list:
            while l < r:
                w[l], w[r] = w[r], w[l]
                l += 1
                r -= 1
            return w
        s = list(s)
        size = len(s)
        l = 0
        r = k - 1
        p = 2 * k -1
        while p <= size-1:
            s = reverseFunction(l,r,s)
            l = p + 1
            r = p + k 
            p = p + 2*k
        p = p - 2 * k 
        res = size - 1 - p

        if res < k:
            s = reverseFunction(p + 1,size -1,s)

        if k <= res < 2*k:
            s = reverseFunction(p + 1,p + k,s)
        
        return ''.join(s)

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        def reverseFunction(l: int, r: int, w:list) -> list:
            while l < r:
                w[l], w[r] = w[r], w[l]
                l += 1
                r -= 1
            return w
        s = list(s)
        length = len(s)
        p = 0
        while p < length:
            if p + k <= length:
                s = reverseFunction(p, p + k -1, s)
            else:
                s = reverseFunction(p, length - 1, s)
            p += 2*k
        return ''.join(s)

---

剑指Offer 05.替换空格

这题虽然简单，但是也是借这个题目才知道，原来在 Python 和 Java 中，字符串都被设计成不可变的类型，而在C++中是可变的。看了这种倒序遍历修改的思想，把Python里用了这种思想的代码粘过来。

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:
        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)

---

Leetcode151.翻转字符串里的单词

本题的主要难点在于去除多余的空格，如果不用python里的split()函数的话，手动去实现这一点要注意的细节比较多。值得一提的是去除多余空格函数里的第一层while循环不能换成for循环，因为如果用for循环的话，在结束第二层的while循环以后，快指针fastIndex会出现回退的情况，这就完全错了。

class Solution:
    
    def reverseAll(self, nums, start, end):
        l = start
        r = end
        while l<r:
            nums[l], nums[r] = nums[r], nums[l]
            l += 1
            r -= 1
        return None
    
    def removeExtraSpaces(self, nums):
        slowIndex = 0
        fastIndex = 0 
        while fastIndex< len(nums):
            if nums[fastIndex] != ' ':
                if slowIndex != 0:
                    nums[slowIndex] = ' '
                    slowIndex += 1
                while fastIndex < len(nums) and nums[fastIndex] != ' ':
                    nums[slowIndex] = nums[fastIndex]
                    slowIndex += 1
                    fastIndex += 1
            fastIndex += 1
        temp = nums[: slowIndex]
        return temp
    
    def reverseEachWord(self, l):
        slowIndex = 0
        fastIndex = 0
        while slowIndex < len(l):
            if l[slowIndex] != ' ':
                left = slowIndex
                right = slowIndex
                while right < len(l) and l[right] != ' ':
                    right += 1
                self.reverseAll(l, left, right - 1 )
            slowIndex = right + 1
            fastIndex = right + 1
        return None
    
    def reverseWords(self, s):
        l = list(s)
        l1 = self.removeExtraSpaces(l)
        self.reverseAll(l1,0, len(l1)-1)
        self.reverseEachWord(l1)
        return ''.join(l1)

---

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

太巧妙的操作

class Solution:
    
    def reverseAll(self, s, left, right):
        l = left
        r = right
        while l < r:
            s[l], s[r] = s[r], s[l]
            r -= 1
            l += 1

    
    def reverseLeftWords(self, s: str, n: int) -> str:
        l = list(s)
        # piece1 = l[:n]
        # piece2= l[n+1:]
        self.reverseAll(l, 0, n-1)
        self.reverseAll(l, n, len(l)-1)
        self.reverseAll(l,0,len(l)-1)
        return ''.join(l)