代码随想录算法训练营|Day 9

Day 9

今日任务

● 151.翻转字符串里的单词

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

● 28. 实现 strStr()

● 459.重复的子字符串

● 字符串总结

● 双指针回顾

详细布置

151.翻转字符串里的单词

建议：这道题目基本把 刚刚做过的字符串操作 都覆盖了，不过就算知道解题思路，本题代码并不容易写，要多练一练。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0151.翻转字符串里的单词.html

class Solution:
    def reverse_word(self, s:list, start:int,end:int):
        while start < end:
            s[start],s[end] = s[end],s[start]
            start += 1
            end -= 1

    def reverseWords(self, s: str) -> str:
        #step1 remove extra space to get a new string
        res = ""
        fast = 0
        s = list(s)
        s.reverse()
        while fast < len(s):
            if s[fast] != " ":
                if len(res) != 0:
                    res += " "
                while fast < len(s) and s[fast] != " ":
                    res += s[fast]
                    fast += 1
            else:
                fast += 1
        #step2 reverse words
        res = list(res)
        p1,p2=0,0
        while p2 <= len(res):
            if p2 == len(res) or res[p2] == " ":
                self.reverse_word(res,p1,p2-1)
                p1 = p2+1
                p2 +=1
            else:
                p2+=1
        return "".join(res)

💡

这段代码是一个实现 反转字符串中的单词顺序 的方法。

代码目标

给定一个字符串 s，可能包含多余空格，返回单词顺序反转后的字符串，要求：

• 单词之间只有一个空格
• 没有前导或尾随空格
• 每个单词内部顺序不变

例如：

输入: "  the sky  is  blue "
输出: "blue is sky the"

代码结构

1️⃣ single_reverse 函数

这是一个帮助函数，用于反转列表中从 start 到 end 的部分。

def single_reverse(self, s, start: int, end: int):
    while start < end:
        s[start], s[end] = s[end], s[start]
        start += 1
        end -= 1

作用：就像手写反转一样，从两边往中间交换。

2️⃣ 反转整体字符串并去掉多余空格

s = list(s)        # 转成列表方便操作
s.reverse()        # 整体反转字符串

比如：

原字符串: "  the sky  is  blue "
转列表后整体反转: [' ', ' ', 'e', 'u', 'l', 'b', ' ', ' ', 's', 'i', ' ', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't', ' ']

然后：

result = ""
fast = 0
while fast < len(s):
    if s[fast] != " ":
        if len(result) != 0:
            result += " "
        while s[fast] != " " and fast < len(s):
            result += s[fast]
            fast += 1
    else:
        fast += 1

这部分逻辑：

• 遇到非空格字符，开始收集单词
• 如果 result 已经有内容，先补一个空格（保证单词之间一个空格）
• 收集完整个单词字符
• 自动跳过多余空格

例子：

经过这部分，result 可能是：

"eulb si yks eht"

（单词顺序对了，但每个单词是反的）

3️⃣ 逐个单词反转回来

result = list(result)  # 转成列表方便操作
slow = 0
fast = 0
while fast <= len(result):
    if fast == len(result) or result[fast] == " ":
        self.single_reverse(result, slow, fast - 1)
        slow = fast + 1
        fast += 1
    else:
        fast += 1

👉 这部分逻辑：

• 找到每个单词的范围（由空格分隔或到结尾）
• 调用 single_reverse 反转单词
• 更新 slow 到下一个单词的起点

4️⃣ 最终返回

return "".join(result)

把列表重新拼成字符串。

整体流程图解

1️⃣ " the sky is blue "

2️⃣ 反转整体变成：" eulb si yks eht "

3️⃣ 去空格拼单词变成："eulb si yks eht"

4️⃣ 每个单词反转："blue is sky the"

💡

列表（list） 和 字符串（str） 在 Python 里的 reverse 相关操作。

列表可以直接使用 reverse() 方法

lst = [1, 2, 3, 4]
lst.reverse()
print(lst)  # 输出: [4, 3, 2, 1]

• reverse() 是列表的内置方法
• 它会 就地修改原列表（in-place），返回值是 None

字符串不能用 reverse() 方法

字符串没有 reverse() 方法，因为字符串是 不可变对象（immutable）。

但你可以用切片的方式反转字符串：

s = "abcd"
reversed_s = s[::-1]
print(reversed_s)  # 输出: "dcba"

或者用 reversed() 和 join()：

s = "abcd"
reversed_s = ''.join(reversed(s))
print(reversed_s)  # 输出: "dcba"

• reversed(s) 返回一个迭代器，不是字符串
• 需要用 ''.join() 拼成字符串

💡

在Python中，如果你对字符串用 list()，它会把每个字符都作为列表的一个元素。

来看个简单例子：

s = "abc def"
lst = list(s)
print(lst)

输出：

['a', 'b', 'c', ' ', 'd', 'e', 'f']

每个字符，包括空格 ' '，都变成列表的一个元素。

为什么要转成列表？

因为：

• 字符串是 不可变的（immutable），不能直接修改它的某个位置。
• 列表是 可变的（mutable），可以像 lst[0] = 'z' 这样修改内容。

所以在代码里：

s = list(s)

是为了方便后续：

s[start], s[end] = s[end], s[start]

这种原地交换操作。

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

建议：题解中的解法如果没接触过的话，应该会想不到

题目链接/文章讲解：

右旋转

知识：先改变段顺序，再改变字符顺序

num_seg = int(input())
s = input()
s = s[::-1]
s = s[:num_seg][::-1] + s[num_seg:][::-1]
print(s)

#获取输入的数字k和字符串
k = int(input())
s = input()

#通过切片反转第一段和第二段字符串
#注意：python中字符串是不可变的，所以也需要额外空间
s = s[len(s)-k:] + s[:len(s)-k]
print(s)

💡

这句代码利用了 Python 的切片（slice）语法，把字符串的后 k 个字符“提取”到前面，等价于对字符串做“向右旋转”操作：

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

print(s[-k:] + s[:-k])

• s[-k:]
  • 负索引 k 相当于 len(s) - k。
  • 所以 s[-k:] 就是从第 len(s) - k 个位置开始，一直到末尾的子串，也就是原字符串的最后 k 个字符。
• s[:-k]
  • 等价于 s[0:len(s)-k]，取从开头到第 len(s) - k（不含）位置的子串，也就是剩下的前面那部分。

把这两段拼起来：

s[-k:] + s[:-k]

就把原来后 k 个字符挪到了最前面，实现了“右旋转 k 位”。

举个例子

s = "abcdef"
k = 2

# s[-2:] => 从索引 4 到末尾，结果是 "ef"
# s[:-2] => 从索引 0 到 4（不含），结果是 "abcd"

print(s[-k:] + s[:-k])  # 输出 "efabcd"

注意

1. 如果你想处理 k ≥ len(s) 的情况，最好先做取模：

   k %= len(s)
   

   这样就不会因为 -k 超出范围导致逻辑不易理解。

2. 这两段切片都不会修改原字符串，而是各自产生新的子串，再通过 + 拼接成最终结果。

💡

字符串（str）类型本身没有 .reverse() 方法，因为它是不可变（immutable）的。如果你想反转字符串，可以用两种常见方法：

1. 切片（slicing）：

   s = "hello"
   rev = s[::-1]
   print(rev)  # olleh
   

   这里 [::-1] 表示从头到尾、步长为 -1，直接得到反转后的新字符串。

2. 内置函数 reversed()：

   s = "hello"
   rev = "".join(reversed(s))
   print(rev)  # olleh
   

   reversed(s) 会返回一个反向迭代器，再用 "".join(...) 拼回字符串。

如果你把字符串转换成列表，就可以用列表的 .reverse() 方法再 join 回去：

s = "hello"
lst = list(s)
lst.reverse()        # 原地 reverse
rev = "".join(lst)
print(rev)  # olleh

💡

在 Python 里，s[::-1] 会返回字符串 s 的反转。

例如：

s = "hello"
print(s[::-1])  # 输出 "olleh"

这里的切片含义是：从头到尾，步长为 -1。

28. 实现 strStr() （本题可以跳过）

因为KMP算法很难，大家别奢求 一次就把kmp全理解了，大家刚学KMP一定会有各种各样的疑问，先留着，别期望立刻啃明白，第一遍了解大概思路，二刷的时候，再看KMP会 好懂很多。

或者说大家可以放弃一刷可以不看KMP，今天来回顾一下之前的算法题目就可以。

因为大家 算法能力还没到，细扣 很难的算法，会把自己绕进去，就算别人给解释，只会激发出更多的问题和疑惑。所以大家先了解大体过程，知道这么回事， 等自己有 算法基础和思维了，在看多看几遍视频，慢慢就理解了。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0028.实现strStr.html

💡

KMP算法解决字符串匹配问题

文本串/模式串: 文本串中是否出现过这个模式串

暴力匹配 O(m*n) m是模式串的长度 n为文本串的长度

---

求前缀表

aabaaf

前缀

a

aa

aab

aaba

aabaa

但是aabaaf就不是前缀。前缀不应包括尾字母

后缀：只包含尾字母，不包含首字母的所有子串

f

af

aaf

baaf

abaaf

最长相等前后缀(长度)：

a 0

aa 1 前缀a 后缀a

aab 0

aaba 1

aabaa 2

aabaaf 0

---

对于模式串，去计算最长相等前后缀(长度)表

用模式串去匹配文本串时，遇到不匹配的char，用模式串中它前一个char的表中数字（长度）来跳

这个长度作为下标刚好可以使我们跳到下一个需要匹配的位置

failureFunction(P):             # 输入：模式串 P，长度 m
  F[0] = 0                      # F[0] 永远是 0，因为单字符没有真前后缀（proper prefix/suffix）
  j = 1, len = 0                # j 用来扫描下标 1…m-1，len 记录“当前最长前后缀长度”（matched length）

  while j < m do                # 对 P[1..m-1] 逐个位置填 F[j]
    if P[j] == P[len] then      # 情况 A：当前位置能在更长的前后缀上继续匹配
      len = len + 1             # “匹配长度”加 1
      F[j] = len                # 在 j 位置能匹配的最大前后缀长度
      j = j + 1                 # 继续下一个字符
    else if len > 0 then        # 情况 B：失配，但已有非零的前后缀可回退
      len = F[len - 1]          # 回到上次“可能”的前后缀长度，重用已计算结果（跳过回退 j）
    else                        # 情况 C：失配且 len==0，无任何前后缀可用
      F[j] = 0                  # 说明 P[0..j] 没有非空的真前后缀
      j = j + 1                 # 向右继续
    end if
  end while

  return F                      # 返回长度为 m 的 failure (LPS) 数组

💡

• j 指向当前要处理的子串末尾，也就是模式串 P[0..j] 的最后一个字符的位置，用来计算 F[j]。
• len 是“当前已匹配的最长真前缀–真后缀的长度”（也就是 lps[j-1]）。
  • 这个长度值恰好等于前缀末尾的索引 +1，所以如果你想知道前缀末尾位置，那就是 len-1。

换句话说，len 记录的是“长度”，对应的前缀区间是 P[0..len-1]。当 P[j] == P[len] 时，说明可以把这个长度再加 1；否则根据 len>0 回退到 F[len-1]，继续尝试。

class Solution:
    def getNext(self, next: List[int], s: str) -> None:
        j = 0
        next[0] = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]
            if s[i] == s[j]:
                j += 1
            next[i] = j
    
    def strStr(self, haystack: str, needle: str) -> int:
        if len(needle) == 0:
            return 0
        next = [0] * len(needle)
        self.getNext(next, needle)
        j = 0
        for i in range(len(haystack)):
            while j > 0 and haystack[i] != needle[j]:
                j = next[j - 1]
            if haystack[i] == needle[j]:
                j += 1
            if j == len(needle):
                return i - len(needle) + 1
        return -1

理解错误写出的代码:

class Solution:
    def getNext(self, s: str, next:List[int]):
        next[0] = 0
        j = 0
        for i in range(1, len(s)):
            if s[j] == s[i]:
                j += 1
            while j > 0 and s[j] != s[i]:
                j = next[j-1]
            next[i] = j
            

    def strStr(self, haystack: str, needle: str) -> int:
        if len(needle) == 0:
            return 0
        next = [0] * len(needle)
        self.getNext(needle, next)
        j = 0
        for i in range(len(haystack)):
            if haystack[i] == needle[j]:
                if j == len(needle)-1:
                    return i-j
                j+=1
            else:
                if j > 0:
                    j = next[j-1]
        return -1
            
        

💡

错误原因

你的 getNext 和主循环里都只做了一次匹配／失配处理，没利用好“失配时要不断回退直到能匹配或退到 0”的思路。具体问题有两点：

1. 构造 LPS（next 表）时顺序错了

   if s[j] == s[i]:
       j += 1
   while j > 0 and s[j] != s[i]:
       j = next[j-1]
   next[i] = j
   
   

   这样写，只在第一次匹配时 j+=1，而如果第一次不匹配又回退到某个新 j 后，哪怕新位置能匹配，也不会再 j+=1 了。正确的顺序应当是——先 不停回退（失配时用前面算好的 next 表缩小匹配长度），再尝试 一次匹配：

   def getNext(self, s: str, next: List[int]):
       j = 0
       next[0] = 0
       for i in range(1, len(s)):
           # 失配时不断回退
           while j > 0 and s[i] != s[j]:
               j = next[j-1]
           # 如果能匹配，j 自增
           if s[i] == s[j]:
               j += 1
           next[i] = j
   
   

2. 搜索主串时同样要用 while 回退

   你在 else: 里只做了一次 j = next[j-1]，但可能还要继续回退才会和当前字符匹配；或者回退到 0 后再判断一次才能 j+=1。标准写法也是先 while 回退，再 if 匹配：

   def strStr(self, haystack: str, needle: str) -> int:
       if not needle:
           return 0
       # 构造 next 表
       m = len(needle)
       next = [0] * m
       self.getNext(needle, next)
   
       j = 0
       for i, ch in enumerate(haystack):
           # 失配时回退 j
           while j > 0 and ch != needle[j]:
               j = next[j-1]
           # 匹配就推进
           if ch == needle[j]:
               j += 1
           # j 走到末尾说明找到了
           if j == m:
               return i - m + 1
       return -1
   
   

这样就保证了“失配时多次利用已知前后缀信息回退，再尝试匹配”的 KMP 核心，从而正确构造 next 表并在线性时间内完成搜索。

459.重复的子字符串 （本题可以跳过）

本题算是KMP算法的一个应用，不过 对KMP了解不够熟练的话，理解本题就难很多。

我的建议是 KMP和本题，一刷的时候 ，可以适当放过，了解怎么回事就行，二刷的时候再来硬啃

题目链接/文章讲解/视频讲解：https://programmercarl.com/0459.重复的子字符串.html

💡

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

KMP最长相等前后缀

💡

如果这个字符串s是由重复子串组成，那么最长相等前后缀不包含的子串是字符串s的最小重复子串

最长相等前后缀不包含的子串已经是字符串s的最小重复子串，那么字符串s一定由重复子串组成，

class Solution:
    def getNext(self, s:str, next:List[int]):
        next[0] = 0
        j = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j-1]
            if s[i] == s[j]:
                j += 1
            next[i] = j 
    def repeatedSubstringPattern(self, s: str) -> bool:
        if len(s) == 0:
            return False
        next = [0]* len(s)
        self.getNext(s,next)
        #next[-1]:最长相等前后缀的长度
        #len(s) - next[-1]:不属于这个最长前后缀的部分/最长相等前后缀不包含的子串的长度
        #如果len % (len - (next[len - 1] + 1)) == 0 
        #则说明数组的长度正好可以被 最长相等前后缀不包含的子串的长度整除
        #说明该字符串有重复的子字符串
        if next[-1] != 0 and len(s) % (len(s) - next[-1]) == 0:
            return True
        return False

        
        

字符串总结

比较简单，大家读一遍就行

题目链接/文章讲解：https://programmercarl.com/字符串总结.html

双指针回顾

此时我们已经做过10道双指针的题目了，来一起回顾一下，大家自己也总结一下双指针的心得

文章讲解：https://programmercarl.com/双指针总结.html