Leetcode刷题记录（代码随想录day07）

Day 07

今天开始字符串

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

解：比链表简单，因为字符串空间是连续的，直接指针+1或者-1就行了

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

541. 反转字符串 II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个，则将剩余字符全部反转。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

解：好像也没什么难的……注意python的字符串不能直接修改，需要转换成列表

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        s = list(s)
        for i in range(0,len(s),2*k):
            if i+k > len(s):
                p = i
                q = len(s)-1
                while p < q:
                    temp = s[p]
                    s[p] = s[q]
                    s[q] = temp
                    p += 1
                    q -= 1
            else:
                p = i
                q = i+k-1
                while p < q:
                    temp = s[p]
                    s[p] = s[q]
                    s[q] = temp
                    p += 1
                    q -= 1
        return ''.join(s)

剑指 Offer 05. 替换空格

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

解：从后往前会更节约时间。注意一个空格只需要新增两个位置

class Solution:
    def replaceSpace(self, s: str) -> str:
        head = len(s)-1
        if head <0:
            return s
        for i in s:
            if i == ' ':
                s += 'oo'
        tail = len(s)-1
        s = list(s)
        while head>=0:
            if s[head] != ' ':
                s[tail] = s[head]
                tail -= 1
                head -= 1
            else:
                s[tail-2:tail+1] = '%20'
                tail -= 3
                head -= 1
        return ''.join(s)

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中单词的顺序。单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

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

解：如果单独建立一个数组来翻转就太简单了。可以先翻转所有字符，然后一个一个单词翻转回来。注意各种空格的去除。

  class Solution:
        def reverse(self, s):
            head = 0
            tail = len(s) - 1
            while head < tail:
                temp = s[head]
                s[head] = s[tail]
                s[tail] = temp
                head += 1
                tail -= 1
            return s
    
        def reverseWords(self, s: str) -> str:
            s = list(s)
            head = 0
            tail = len(s) - 1
            # 去除开头结尾空格
            while s[head] == " ":
                head += 1
            while s[tail] == " ":
                tail -= 1
            s = s[head:tail+1]
            # 去除中间段空格
            i = 0
            while i < len(s):
                while s[i] == ' ' and s[i+1] == ' ':
                    s = s[:i]+s[i+1:]
                i += 1
            s = self.reverse(s)  # 翻转字符串
            # 翻转单词
            head, tail = 0, 0
            while tail<len(s):
                while tail<len(s) and s[tail] != ' ':  # 末尾不用+1
                    tail += 1
                s[head:tail] = self.reverse(s[head:tail])
                head = tail+1
                tail += 1
            return ''.join(s)

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

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

解：类似上题，两次翻转。比如：abcdefg -> gfedcba -> cdefgab。

  class Solution:
        def reverseLeftWords(self, s: str, n: int) -> str:
            return s[n:]+s[:n]
        
    # 翻转做法
    class Solution:
        def reverse(self, s):
            head = 0
            tail = len(s) - 1
            while head < tail:
                temp = s[head]
                s[head] = s[tail]
                s[tail] = temp
                head += 1
                tail -= 1
            return s
    
        def reverseLeftWords(self, s: str, n: int) -> str:
            s = list(s)
            s = self.reverse(s)
            s = self.reverse(s[:len(s)-n]) + self.reverse(s[len(s)-n:])
            return ''.join(s)