字符串基础系列1

344 反转字符串
- 我的代码
- 代码随想录的代码
- 力扣的示例代码
541 反转字符串II
- 我的代码
- 代码随想录的代码
- 力扣的示例代码
剑指offer-05 替换空格
- 我的代码
- 代码随想录的代码
- 力扣的示例代码
151 反转字符串中的单词
- 我的代码
- 代码随想录的代码
- 力扣的示例代码
一段用于复制的标题
- 我的代码
- 力扣的示例代码

344 反转字符串

写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

思路简单，想到了使用双指针法。只不过一开始的想法中，还要对字符串为奇数还是偶数分类讨论，但是看了代码随想录的解答后，发现，left < right 就可以了，不需要分类讨论。

我的代码

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s) - 1
        
        # 该方法已经不需要判断奇偶数，经测试后时间空间复杂度比用 for i in range(len(s)//2)更低
        # 因为while每次循环需要进行条件判断，而range函数不需要，直接生成数字，因此时间复杂度更低。推荐使用range
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1

代码随想录的代码

（版本一）双指针

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s) - 1
        
        # 该方法已经不需要判断奇偶数，经测试后时间空间复杂度比用 for i in range(len(s)//2)更低
        # 因为while每次循环需要进行条件判断，而range函数不需要，直接生成数字，因此时间复杂度更低。推荐使用range
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1

（版本二）使用栈

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        stack = []
        for char in s:
            stack.append(char)
        for i in range(len(s)):
            s[i] = stack.pop()

（版本三）使用range

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        n = len(s)
        for i in range(n // 2):
            s[i], s[n - i - 1] = s[n - i - 1], s[i]

（版本四）使用reversed

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = reversed(s)

（版本五）使用切片

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

（版本六）使用列表推导

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = [s[i] for i in range(len(s) - 1, -1, -1)]

力扣的示例代码

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        return s.reverse()

541 反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

我的代码

用麻烦的方法做出来了。

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



        elif n < k :
            s = self.re_k(s,len(s))
            return ''.join(s)
        else :
            s[0:k] = self.re_k(s[0:k],k)
            return ''.join(s)
    def re_k(self, s , k) -> str:
        
        left, right = 0, k - 1
        
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
        return ''.join(s)

代码随想录的代码

直接被骂的狗血淋头。
在这里插入图片描述

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """
        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)

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        # 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

力扣的示例代码

牛逼，这么简洁，使用切片

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        flip=1
        ans=''
        for i in range(0,len(s),k):
            a=s[i:i+k]
            flip=-flip
            ans+=a[::flip]
        return ans

剑指offer-05 替换空格

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

输入：s = “We are happy.”
输出：“We%20are%20happy.”

我的代码

这道题第一眼看上去基础逻辑就是一个遍历，但是在空间上只击败了7%，应该有很牛的写法，学习一下。

class Solution:
    def replaceSpace(self, s: str) -> str:
        res = ''
        n = len(s)
        for i in range(n):
            if s[i]==' ':
                res = res + '%20'
            else :
                res = res + s[i]
        return res

代码随想录的代码

代码随想录中给出了使用双指针想法来解决本题的思路，其出发点是不申请额外的存储空间，但是需要知道字符串中有几个空格，所以还是用了count方法，内部逻辑也是遍历了一遍数组，不过O(2n)和O(n)没什么区别，还是要承认这种省空间的做法。

下面给出链接，一些相关分析与总结去看原文就好了。
代码随想录–替换空格

（版本一）转换成列表，并且添加相匹配的空间，然后进行填充

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)

（版本二）添加空列表，添加匹配的结果

class Solution:
    def replaceSpace(self, s: str) -> str:
        res = []
        for i in range(len(s)):
            if s[i] == ' ':
                res.append('%20')
            else:
                res.append(s[i])
        return ''.join(res)

（版本三）使用切片

class Solution:
    def replaceSpace(self, s: str) -> str:
        n = len(s)
        for e, i in enumerate(s[::-1]):
            print(i, e)
            if i == " ":
                s = s[: n - (e + 1)] + "%20" + s[n - e:]
            print("")
        return s

这里要注意，必须是从后向前遍历，从前向后会与循环冲突。

class Solution:
    def replaceSpace(self, s: str) -> str:
        n = len(s)
        for e, i in enumerate(s[::1]):
            
            if i == " ":
                s = s[: e] + "%20" + s[e+1:]
            
        return s

（版本四）使用join + split

class Solution:
    def replaceSpace(self, s: str) -> str:
        return "%20".join(s.split(" "))

（版本五）使用replace

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

力扣的示例代码

class Solution:
    def replaceSpace(self, s: str) -> str:
        # res=''
        # for si in s:
        #     if si==' ':
        #         res+='%20'
        #     else:
        #         res+=si
        # return res
        return s.replace(' ','%20')

151 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中单词的顺序。(s中至少存在一个单词)

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

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

我的代码

之前一直说，不要用内置函数，但是看了代码随想录的解答后，似乎split()这样的函数可以随便用啊，那问题就没有我想的那么复杂了。

因为Python有大量内置函数的存在，所以处理起来很方便，但是其他语言要复杂上很多，另外本题的处理思路也是要学习的，去看代码随想录的解析即可。

代码随想录–反转字符串中的单词

代码随想录的代码

（版本一）先删除空白，然后整个反转，最后单词反转。因为字符串是不可变类型，所以反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是O(1)

class Solution:
    def reverseWords(self, s: str) -> str:
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

（版本二）使用双指针

class Solution:
    def reverseWords(self, s: str) -> str:
        # 将字符串拆分为单词，即转换成列表类型
        words = s.split()

        # 反转单词
        left, right = 0, len(words) - 1
        while left < right:
            words[left], words[right] = words[right], words[left]
            left += 1
            right -= 1

        # 将列表转换成字符串
        return " ".join(words)

力扣的示例代码

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