字符串基础系列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
