leetcode 打卡 day8

字符串

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

344.反转字符串

1、反转字符串使用双指针解法
2、前面字母与后面字母对应交换

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
        return s

541. 反转字符串II

1、构造一个函数来交换字符串

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        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])
        return ''.join(res)

剑指Offer05.替换空格

方法1：借助额外的列表，方法简单。

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        res = []
        for i in s:
            if i == ' ':
                res.append('%20')
            else:
                res.append(i)
        return ''.join(res)

方法2：
1、从后向前填充元素，避免了从前先后填充元素要来的 每次添加元素都要将添加元素之后的所有元素向后移动。
2、使用双指针法，先扩展数组。
3、在while循环中， 将原数组最后的元素，赋值到新数组最后的元素。如果在赋值的过程中发现了空格元素，用%20代替空格赋值到新数组中
4、最后将数组转换为字符串

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: 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+1), 左闭右开
                res[right - 2: right + 1] = '%20'
                right -= 3
            left -= 1
        return ''.join(res)

544. 151.翻转字符串里的单词

1、本题可以使用简单的方法，即新建一个字符串进行操作。但本题使用了O(1)空间复杂度的写法。
2、首先去除字符串两边多余的空格，使用trim_spaces函数，注意temp[-1] != ’ ’ , 意思是s[left] 是空格，但temp中前一个元素不为空格。
3、reverse_string函数作用是翻转字符串
4、reverse_each_word翻转每个单词。使用了双指针的方法，end用来判断每个单词的结尾。

class Solution(object):
      #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=right-1
            tmp=[]
            while left<=right:                                    #去除单词中间多余的空格
                if s[left]!=' ':
                    tmp.append(s[left])
                elif tmp[-1]!=' ':                                  #当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的
                    tmp.append(s[left])
                left+=1
            return tmp
    #2.翻转字符数组
    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)
                start=end+1
                end+=1
            return None
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        l = self.trim_spaces(s)                     #输出：['t', 'h', 'e', ' ', 's', 'k', 'y', ' ', 'i', 's', ' ', 'b', 'l', 'u', 'e'
        self.reverse_string( l,  0, len(l) - 1)   #输出：['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
        self.reverse_each_word(l)               #输出：['b', 'l', 'u', 'e', ' ', 'i', 's', ' ', 's', 'k', 'y', ' ', 't', 'h', 'e']
        return ''.join(l)                                 #输出：blue is sky the

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

方法1：

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        return s[n:] + s[0:n]

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

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        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)