字符串--双指针/反转系列

344. 反转字符串

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

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

示例 1：

输入：s = [“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”] 输出：[“h”,“a”,“n”,“n”,“a”,“H”]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 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

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

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

示例 1：

输入：s = “abcdefg”, k = 2 输出：“bacdfeg”
示例 2：

输入：s = “abcd”, k = 2 输出：“bacd”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        def reverse(st):
            l,r=0,len(st)-1
            while(l<r):
                st[l],st[r] = st[r],st[l]
                l+=1
                r-=1
            return st
        
         
        n = len(s)
        nums=list(s)

        for i in range(0,n,2*k):
            # i=      0,2K,4K
            # 翻转的是k,3k,5k
           nums[i:i+k] = reverse(nums[i:i+k])
        return ''.join(nums)
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        res=list(s)
        for i in range(0,len(s),2*k):
            '''
              1. 每隔 2k 个字符的前 k 个字符进行反转
              2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
              [::-1] 顺序相反操作
              [-1] 读取倒数第一个元素
              a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。

            '''
            if i+k<=len(s):
                res[i:i+k] = res[i:i+k][::-1]
                continue
            
            res[i:len(s)] =res[i:len(s)][::-1]
        return ''.join(res)

剑指 Offer 05. 替换空格

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

示例 1：

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

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:
    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)
            

151. 颠倒字符串中的单词

给你一个字符串 s ，颠倒字符串中 单词 的顺序。

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

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

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

示例 1：

输入：s = “the sky is blue” 输出：“blue is sky the”
示例 2：

输入：s = " hello world " 输出：“world hello” 解释：颠倒后的字符串中不能存在前导空格和尾随空格。
示例3：

输入：s = “a good example” 输出：“example good a”
解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-words-in-a-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """

        res = s.split(' ')
        s=''
        # 逆序找非空字符串
        for i in range(len(res)-1,-1,-1):
            if res[i]!='':
                s+=res[i]+" "
        # 去掉最后一个空格
        return s[0:len(s)-1]

思路：
移除多余空格
将整个字符串反转
将每个单词反转
举个例子，源字符串为："the sky is blue "

移除多余空格 : “the sky is blue”
字符串反转：“eulb si yks eht”
单词反转：“blue is sky the”

class Solution:
    #1.去除多余空格
    def removespace(self,s):
        l,r = 0,len(s)-1
        # 去除开头空格
        while l<=r and s[l]==' ':
            l+=1
        # 去除尾部空格
        while l<=r and s[r]==' ':
            r-=1
        # 去除单词中间空格
        tmp=[]
        while l<=r:
            if s[l]!=' ':
                tmp.append(s[l])

            ##当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的 比如'  hello'
            elif tmp[-1]!=' ':
                tmp.append(s[l])
            l+=1
        return tmp
    #2.翻转字符数组
    def reversestring(self,nums,left,right):
        while left<=right:
            nums[left], nums[right]=nums[right],nums[left]
            left+=1
            right-=1
        return None
    #3.翻转每个单词
    def reverse_echo_word(self,nums):
        s=0
        e=0
        n=len(nums)
        while s<n:
            while e<n and nums[e]!=' ':
                e+=1
            # e会跳出循环等于n 所以-1
            self.reversestring(nums,s,e-1)
            # 从下一个单词开始
            s=e+1 
            e+=1
        return None
    

    def reverseWords(self, s: str) -> str:
        li = self.removespace(s)#输出：['t', 'h', 'e', ' ', 's', 'k', 'y', ' ', 'i', 's', ' ', 'b', 'l', 'u', 'e'
        self.reversestring(li,0,len(li)-1)#输出：['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
        self.reverse_echo_word(li)#输出：['b', 'l', 'u', 'e', ' ', 'i', 's', ' ', 's', 'k', 'y', ' ', 't', 'h', 'e']
        return ''.join(li) #输出：blue is sky the
 

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

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

示例 1：

输入: s = “abcdefg”, k = 2 输出: “cdefgab”
示例 2：

输入: s = “lrloseumgh”, k = 6 输出: “umghlrlose”

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

列表 取余

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = []
        for i in range(n, len(s)):
            res.append(s[i])
        for i in range(n):
            res.append(s[i])
        return ''.join(res)

 

字符串 取余

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = ""
        for i in range(n, len(s)):
            res += s[i]
        for i in range(n):
            res += s[i]
        return res

 '''
化简 

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = ""
        for i in range(n, n + len(s)):
            res += s[i % len(s)]
        return res

 
'''