（二刷）代码随想录算法训练营day8 | 344.反转字符串，541. 反转字符串II，剑指Offer 05.替换空格，151.翻转字符串里的单词

344.反转字符串

• 双指针

• 注意：库函数的使用；若是其中的一小步，可以使用且需了解其实现原理。

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:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
            

        

541. 反转字符串II

• 根据题目要求，第一次写了如下解法，但提交时超时，结果发现是print()造成的

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        
        s = list(s)
        for i in range(0, len(s), 2*k):
            s[i:(k+i)]=self.reverse(s[i:(k+i)])
            #print(s)
        return ''.join(s)
        
        
        
    def reverse(self, s):
        left = 0
        right = len(s)-1
        while left <= right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
            
        return s

剑指Offer 05.替换空格

• 需要将string转换为list（直接或间接），那么这就需要辅助空间了

• 因为strings are immutable, 因此python无法原地修改stirng，因此不能做到空间复杂度O(1)。（不能像list一样直接赋值，即使string的搜索方式跟list一样。）

• Q: space complexity of enumerate() and replace() methods in 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(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        return "%20".join(s.split(" "))

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

151.翻转字符串里的单词（medium）

• 利用split来解题， space complexity: O(n)

• followup解题思路：

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

• follow python版题解

• Q：代码随想录的python题解，在trim_spaces function 里面，那个tmp不是也是space complexity O(n)吗？这样岂不是毁了整篇的努力？

• S: 这是python语言本身的问题，strings are immutable，无法原地修改string，只能申请辅助空间。因此，对于python刷题而言，利用split没问题。但是代码随想录的解题思路依然是可以借鉴学习的。

class Solution:
    def reverseWords(self, s: str) -> str:
        return ' '.join(s.split()[::-1])

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

• 几种题解都是space complexity: O(n) ，原因同上。

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        s = list(s)
        while n > 0:
            s.append(s.pop(0))
            n -= 1

        return ''.join(s)

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

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:

        s = list(s)
        s[:n] = reversed(s[:n])
        #print(reversed(s[:n]))
        s[n:] = reversed(s[n:])
        s.reverse()
        return ''.join(s)

注意：

• 图三，最后不可用reversed(s)，因为reversed()返回的是一个反转迭代器，可以尝试uncomment print语句看一下输出；
• 也就是说，在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者List, 或者next()等方法，获取作用后的值。
• reversed()可以用在list, tuple, string
• .reverse()则是反转原列表，只可用于list

插入知识点：

        切片是值传递，数组是引用传递，也就是切片是造了一个新的局部变量，只在调用这个函数的栈里有效。（From c++鲁智深）

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
    
        s = list(s)
        end = len(s) - 1
        self.reverseHelper(s, 0, n - 1)
        self.reverseHelper(s, n, end)
        self.reverseHelper(s, 0, end)
        return ''.join(s)

    #手动实现内置reversed函数，这样就跟图三一个解法
    def reverseHelper(self, lst, left, right):
        while left < right:
            lst[left], lst[right] = lst[right], lst[left]
            left += 1
            right -= 1
        return lst

总结：

• 第一次感受到为什么python在性能上是不如某些经典语言的。

• string的解题思路与list其实是很相似的，只是对于python而言，strings are immutable. 这一点导致需要先将string转换成list（直接或间接），但问题就是无法做到空间复杂度O(1).