学习记录@代码随想录day8:字符串part01

zmmyzdq

已于 2023-07-19 15:31:03 修改

阅读量113

点赞数

文章标签： python 开发语言

于 2023-07-19 15:29:09 首次发布

本文链接：https://blog.csdn.net/qq_40357993/article/details/131801069

版权

文章介绍了多种在Python中反转字符串的方法，包括双指针、栈、库函数`reversed`以及切片操作。此外，还讨论了反转字符串II的问题，涉及到更复杂的字符串翻转逻辑。文中提供了详细的代码示例和解题思路，如使用切片避免边界条件处理和优化空间效率。

摘要由CSDN通过智能技术生成

学习记录@代码随想录day8:字符串part01

344.反转字符串

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

看了眼讲解说用双指针法，自己写出来了，(^▽)

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

其他方法

'''使用栈'''
#这种方法也很好理解，先进后出
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()
'''库函数reversed'''
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
		s[:]=reversed(s)
		return s
		
'''使用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]
            #s[i]=s[n-i-1]
            #s[n-i-1]=s[i]
        return s

在写的时候发现用s[i]=s[n-i-1]，再用s[n-i-1]=s[i]是错误的，区别在于正确的写法就是用于两个位置的元素交换，而错误的方法是进行赋值，没有进行交换，如果要正确的话应该需要加一个中间值。

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):
            temp=s[i]
            s[i]=s[n-i-1]
            s[n-i-1]=s[i]
        return s

541. 反转字符串II

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

自己写了下，绕晕了，情况太多了，没有处理好，最后还是有的输入出错

class Solution:
    #反转字符串     
    def reverseStr(self, s: str, k: int) -> str:
        s=list(s)
        s_len=len(s)
        if s_len<k:
            s[:]=reversed(s)
            result_str = ''.join(s)
            return result_str
        elif s_len==k:
            s[:]=reversed(s)
            result_str = ''.join(s)
            return result_str
        n=s_len//(2*k)
        #进行翻转，只翻转前k个
        for i in range(n):
            s[i:i+k]=reversed(s[i:i+k])
            #print('翻转',s)
        
        if s_len>n*2*k:
            m=s_len-n*2*k
           # print(m)
            if m>k:
                s[n*2*k:n*2*k+k]=reversed(s[n*2*k:n*2*k+k])
                result_str = ''.join(s)
                return result_str
            else:
                result_str = ''.join(s)
                return result_str
        else:
            result_str = ''.join(s)
            return result_str

随想录代码

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

剑指Offer 05.替换空格

解题思路：
1.扩充数组到每个空格替换成“20%”的大小。
2.然后从前往后向前替换空格，也就是双指针法。
3.i只想新指针的末尾，j指向就指针的末尾
为什么从后往前，因为从前往后的话需要将添加元素之后的所有元素向后移动。
很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。
这样做不需要申请新的数组空间。

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
            #遇到空格时，往连续的三个空格中填%20,从0开始，连续三个空格为right-2:right+1
            #例如[2:5]取2,3,4
            else:
                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)
        #s[::-1]是对字符串s进行反向切片操作，将字符串翻转。
        #enumerate()是一个 Python 内置函数，用于将一个可迭代对象转换为枚举对象。
        #枚举对象可以同时返回元素的索引和值。
        for e,i in enumerate(s[::-1]):
            print(i,e)
            if i == " ":
            	#s[:n-(e+1)]是对字符串s进行切片操作，取出索引为0到n-(e+1)的子字符串。
            	#例如，对于字符串s="hello world"，当e=1时，s[:n-(e+1)]的结果为"hello"。        	
				#s[n-(e+1):]是对字符串s进行切片操作，取出从索引n-(e+1)到末尾的子字符串。
				#例如，对于字符串s="hello world"，当e=1时，s[n-(e+1):]的结果为"orld"。
                s=s[:n-(e+1)]+"%20"+s[n-e:]
                print("")
        return s
'''使用join+split'''
class Solution:
    def replaceSpace(self, s: str) -> str:
    	#s.split(" ")是将字符串s按空格进行切割，得到一个由若干个子字符串组成的列表。
    	#例如，对于字符串s="hello world"，s.split(" ")的结果为['hello', 'world']。
    	#"%20".join(s.split(" "))是将上一步得到的列表中的每个子字符串用"%20"字符串进行连接
    	#并返回连接后的新字符串。
        return "%20".join(s.split(" "))

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

151.翻转字符串里的单词

'''
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，
单词间应当仅用单个空格分隔，且不包含任何额外的空格。
输入：s = "the sky is blue"
输出："blue is sky the"
'''

解题思路：
1.删除多余空格
2.将整个字符串反转
3.将每个单词反转

举个例子，源字符串为："the sky is blue "

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

class Solution:
    def reverseWords(self, s: str) -> str:
        #1.删除多余空格
        #去除字符串s的首尾空格
        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)

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

解题思路：
1.反转区间为前n的字串
2.反转区间为n到末尾的字串
3.反转整个字串

在这里插入图片描述
果然把复杂问题简单化了！偷了个懒自己写了下

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res=list(s)
        res[:n]=reversed(res[:n])
        res[n:]=reversed(res[n:])
        res[:]=reversed(res[:])
        return ''.join(res)

随想录方法

'''使用切片'''
#这个好简单，但我没想到/(ㄒoㄒ)/~~
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        return s[n:]+s[:n]

总结

今天的题比较容易好写，加油加油！
参考链接：https://programmercarl.com/%E5%89%91%E6%8C%87Offer58-II.%E5%B7%A6%E6%97%8B%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC

zmmyzdq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习记录@代码随想录day8:字符串part01

今天的题比较容易好写，加油加油！
复制链接

扫一扫