代码随想录训练营day08|344.反转字符串、541. 反转字符串II、卡码网：54.替换数字 、 151.翻转字符串里的单词

344.反转字符串 

题目链接/文章讲解/视频讲解：代码随想录

双指针法：

class Solution:
    def reverseString(self, s: List[str]) -> 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

题目链接/文章讲解/视频讲解：代码随想录

在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。所以当需要固定规律一段一段去处理字符串的时候，就要在for循环的表达式上做文章了。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        #跟344.反转字符串 这道题一样，定义反转函数
        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)
        #对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        for cur in range(0, len(s), 2 * k):
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)

思考：

1.因为对字符串是固定规律一段一段去处理的，所以在使用for循环时，步数就应该改变了。

1.字符串是不可变的，因此要先转化成列表处理

2. 对于字符串s=’abc’ ,如果使用s[0:999] ⇒ ‘abc’ 字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。      

 卡码网：54.替换数字 

题目链接/文章讲解：代码随想录

def f(s):
    result=list(s)
    for i in range(len(s)):
        if ord('a')<=ord(lst[i])<=ord('z'):
            continue
        else:
            result[i]='number'
    
    return ''.join(result)

s=input()
f(s)

 151.翻转字符串里的单词 

题目链接/文章讲解/视频讲解： 代码随想录

本题的难度：不要使用辅助空间，空间复杂度要求为O(1)。

不能使用辅助空间之后，那么只能在原字符串上下功夫了。

想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。

所以解题思路如下：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

class Solution:
    #去除多余空格
    def trim_space(self,s):
        left,right = 0,len(s)-1
        #去除左右两边空格
        while left<=right and s[left] == ' ':
            left += 1
        while left<=right and s[right] == ' ':
            right -= 1
        
        s=s[left:right+1]
    

        #快慢指针，去除中间多余的指针
        fast,slow = 0,0
        while fast <= len(s)-1:
            if fast >= 1 and s[fast] == ' ' and s[fast-1] == ' ':
                fast += 1
            else:
                s[slow] = s[fast]
                    slow += 1
            fast += 1
        s=s[:slow+1]
        return s
    
    #字符串反转
    def reverse(self,s):
        left, right = 0, len(s) - 1
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
        return s
    
    #单词反转
    def reverse_word(self,res):
        start,end=0,0
        n=len(res)
        while start < n:
            while end < n and  res[end] != ' ':
                end += 1 
            res[start:end] = reverse(res[start:end])
            start = end+1
            end += 1
        return res 

    def reverseWords(self, s):
        s=list(s)
        s=trim_space(s)
        l=reverse(s)
        t=reverse_word(l)
        return "".join(l)

参考文章

卡码网：55.右旋转字符串 

题目链接/文章讲解：

代码随想录

自己思路是让后面k个字符通过不断地与前一个字符进行交换实现最终结果，套了两层循环超时了

k=int(input())
s = list(input())

 
n=len(s)
target = n-k #倒数第k个字符
end = 0 
 
for i in range(k)::
    t = target 
    while t > end:
        s[t-1],s[t] = s[t],s[t-1]
        t -= 1 
        
    end += 1 #倒数第k+1个字符交换到第一个字符就可以了，以此类推
    target += 1 
 
print(''.join(s))

整体反转+局部反转

先整体倒叙，再对两段字符分别进行倒叙操作

class Solution(object):
    def reverseLeftWords(self, s, k):
        def reverse(array,left,right):
            while left<right:
                array[left],array[right] = array[right],array[left]
                left += 1
                right -= 1
        array = list(s)
        reverse(array,0,k-1)
        reverse(array,k,len(s)-1)
        return s

时间复杂度：O(N)

每个元素就操作两次反转，所以说复杂度为O(N)

空间复杂度：O(N)

这个是取决于使用语言的性质，在Python中是O(N)；在C++中是O(1)；如果字符串是可修改的，那么我们可以直接在原字符串上修改，空间复杂度为 O(1)，否则需要使用 O(n) 的空间将字符串临时转换为可以修改的数据结构（例如数组），空间复杂度为 O(n)。

参考文章