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

【参考链接】

344. 反转字符串

【注意】

1.双指针法，原地进行操作。

2.字符串也是一种数组，所以元素在内存中是连续分布。

【代码】

return s.reverse()

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        n = len(s)
        left = 0
        right = n - 1
        # while left < n//2: #奇数时，中间数不需要操作
        #     temp = s[left]
        #     s[left] = s[right]
        #     s[right] = temp
        #     left += 1
        #     right -= 1

        # return s
        # 该方法已经不需要判断奇偶数，经测试后时间空间复杂度比用 for i in range(right//2)更低
        # 推荐该写法，更加通俗易懂
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1

        return s

541. 反转字符串 II

【代码】

s[p: p2][::-1] #反转

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        def reverse_substring(text):
            left = 0
            right = 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)

        #方法2.
        # 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

剑指 Offer 05. 替换空格

【注意】

1.很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

1. 不用申请新数组。
2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

2.

list.append(obj) #在列表末尾添加新的对象，相当于其它语言里的push
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

# 字符串
y = '1345'
list(y) # ['1', '3', '4', '5'] 将列表转换成列表

# 元组
z = ('a', 'b', 'c')
list(z) # ['a', 'b', 'c'] 将元组转换成列表

# 字典
d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
list(d) # ['Name', 'Age', 'Class'] 字典 key 转成列表
list(d.values()) # ['Tom', 7, 'First'] 字典 value 转成列表
# 字典键值对（一个元组）转成列表
list(d.items()) # [('Name', 'Tom'), ('Age', 7), ('Class', 'First')]

s = "We are happy."
s = s.replace(' ', '%20')
print(s)

s = "I love you"
res = " ".join(s.split(" ")[::-1])[::-1]

I evol uoy

" ".join(s.split()) 拼接后的返回值为str类型！

【代码】

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        #方式1
        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)

        #方式2
        return "%20".join(s.split(' '))

        #方式3
        return s.replace(' ', '%20')

151. 反转字符串中的单词

【注意】

1.空间复杂度为O(1).

【代码】

class Solution(object):
    #方式1
    #1.去除多余的空格
    def trim_spaces(self,s):
        n = len(s)
        left = 0
        right = n - 1

        while left <= right and s[left] == ' ':
            #去除开头的空格
            left += 1
        while left <= right and s[right] == ' ':
            right -= 1
        
        tmp = []
        while left <= right:
            #去除单词中间多余的空格，只留一个空格
            if s[left] != ' ':
                tmp.append(s[left])
            elif tmp[-1] != ' ':
                #当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的
                tmp.append(s[left]) #append追加的形式还是字符
            left += 1
        return tmp
    
    #反转字符数组
    def reverse_string(self, nums, left, right):
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1
        
        return None

    #3.翻转每个单词
    def reverse_each_word(self, nums):
        start = 0
        end = 0
        n = len(nums)

        while start < n:
            while end < n and nums[end] != ' ':
                #找到每一个单词
                end += 1
            #对每一个单词再翻转成原来的顺序
            self.reverse_string(nums, start, end-1) #end最后的位置在空格处，所以再减一
            start = end + 1
            end += 1 #下一个单词的首字母
        return None
    #4.翻转字符串里的单词
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        l = self.trim_spaces(s)
        self.reverse_string(l, 0, len(l)-1)
        self.reverse_each_word(l)

        return ''.join(l)

    #方式2
    def reverseWords(self, s):
        s_list = [i for i in s.split(' ') if len(i) > 0]
        return " ".join(s_list[::-1])
        #return " ".join(s.split(" ")[::-1])

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

【注意】

局部反转+整体反转

具体步骤为：

1. 反转区间为前n的子串
2. 反转区间为n到末尾的子串
3. 反转整个字符串

【代码】

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        #方法1 --切片
        return s[n:] + s[0:n]
        
        #方法2 --reversed()
        s = list(s)
        s[0:n] = list(reversed(s[0:n]))
        s[n:] = list(reversed(s[n:]))
        s.reverse()

        return "".join(s)

        #方法3
        def reverse_sub(lst, left, right):
            while left <right:
                lst[left], lst[right] = lst[right], lst[left]
                left += 1
                right -= 1
        
        res = list(s)
        end = len(res) - 1
        reverse_sub(res, 0, n-1)
        reverse_sub(res, n, end)
        reverse_sub(res, 0, end)

        return ''.join(res)