1. 算法训练营第四天核心任务解析
今天我们要啃下两块硬骨头：字符串翻转和子串匹配。作为代码随想录算法训练营的第四天内容，这两道题目看似基础却暗藏玄机。151题要求翻转字符串中的单词顺序（注意不是反转每个单词），而28题需要实现类似C语言中strStr()的功能，即在主串中定位子串首次出现的位置。
特别提醒：很多初学者会把151题误解为简单的字符串整体反转，实际上需要保留单词内部顺序，仅调整单词间的排列顺序。这种理解偏差会导致完全错误的解法。
1.1 翻转字符串里的单词（LeetCode 151）
给定一个字符串，逐个翻转字符串中的单词顺序，同时需要处理多余空格。例如：
输入：" hello world "
输出："world hello"
关键难点在于：
- 需要处理首尾和中间的多余空格
- 不能使用split等内置函数（面试时常见要求）
- 要求O(1)额外空间复杂度（原地修改）
1.2 实现strStr()（LeetCode 28）
实现类似C语言strStr()的功能，即判断needle是否是haystack的子串，如果是则返回首次出现的索引，否则返回-1。例如：
输入：haystack = "hello", needle = "ll"
输出：2
暴力解法虽然直观，但更优的KMP算法才是面试官期待的亮点。不过在实际coding时，建议先写出暴力解法确保正确性，再考虑优化。
2. 翻转字符串的三种解法对比
2.1 语言特性取巧法（不推荐但实用）
Python中可以用一行代码解决：
python复制def reverseWords(s: str) -> str:
return ' '.join(reversed(s.split()))
这种方法利用了语言内置函数，虽然简洁但完全避开了算法考察点，仅适合日常编程使用。
2.2 标准双指针法
更符合面试要求的解法是：
- 去除多余空格（首尾+中间）
- 反转整个字符串
- 逐个反转每个单词
python复制def reverseWords(s: str) -> str:
# 去除空格函数
def trim_spaces(s):
left, right = 0, len(s) - 1
# 去掉首尾空格
while left <= right and s[left] == ' ':
left += 1
while left <= right and s[right] == ' ':
right -= 1
# 去掉中间多余空格
output = []
while left <= right:
if s[left] != ' ':
output.append(s[left])
elif output[-1] != ' ':
output.append(s[left])
left += 1
return output
# 反转字符数组
def reverse(l, left, right):
while left < right:
l[left], l[right] = l[right], l[left]
left += 1
right -= 1
# 反转每个单词
def reverse_each_word(l):
n = len(l)
start = end = 0
while start < n:
while end < n and l[end] != ' ':
end += 1
reverse(l, start, end - 1)
start = end + 1
end += 1
l = trim_spaces(s)
reverse(l, 0, len(l) - 1)
reverse_each_word(l)
return ''.join(l)
2.3 使用栈的解法
另一种思路是利用栈后进先出的特性：
python复制def reverseWords(s: str) -> str:
stack = []
word = []
for ch in s + ' ': # 加空格触发最后单词入栈
if ch != ' ':
word.append(ch)
elif word:
stack.append(''.join(word))
word = []
return ' '.join(reversed(stack))
实测对比：在LeetCode上，双指针法运行时间36ms（击败90%），内存16.5MB；栈方法40ms（击败70%），内存16.7MB。虽然差距不大，但在大字符串处理时双指针的空间优势会更明显。
3. strStr()的四种实现策略
3.1 暴力匹配（面试必写）
最直观的解法是双重循环比较：
python复制def strStr(haystack: str, needle: str) -> int:
L, n = len(needle), len(haystack)
for start in range(n - L + 1):
if haystack[start: start + L] == needle:
return start
return -1
时间复杂度O((N-L)L)，空间O(1)。当needle很短时效率尚可。
3.2 Rabin-Karp算法（哈希优化）
通过滚动哈希减少比较次数：
python复制def strStr(haystack: str, needle: str) -> int:
L, n = len(needle), len(haystack)
if L > n:
return -1
# 基数和模数
a = 26
modulus = 2**31
# 计算needle哈希和初始窗口哈希
h = 0
ref_h = 0
for i in range(L):
h = (h * a + ord(haystack[i]) - ord('a')) % modulus
ref_h = (ref_h * a + ord(needle[i]) - ord('a')) % modulus
if h == ref_h and haystack[:L] == needle:
return 0
# 预计算a^L % modulus
aL = pow(a, L, modulus)
for start in range(1, n - L + 1):
# 滚动哈希计算
h = (h * a - (ord(haystack[start - 1]) - ord('a')) * aL +
ord(haystack[start + L - 1]) - ord('a')) % modulus
if h == ref_h and haystack[start:start + L] == needle:
return start
return -1
平均时间复杂度O(N)，最坏情况仍为O((N-L)L)。
3.3 KMP算法（面试加分项）
KMP的核心是预处理模式串得到next数组：
python复制def strStr(haystack: str, needle: str) -> int:
L, n = len(needle), len(haystack)
if L == 0:
return 0
# 构建next数组
next = [0] * L
j = 0
for i in range(1, L):
while j > 0 and needle[i] != needle[j]:
j = next[j - 1]
if needle[i] == needle[j]:
j += 1
next[i] = j
# 匹配过程
j = 0
for i in range(n):
while j > 0 and haystack[i] != needle[j]:
j = next[j - 1]
if haystack[i] == needle[j]:
j += 1
if j == L:
return i - L + 1
return -1
时间复杂度O(N+L)，空间O(L)。适合处理长文本重复模式的情况。
3.4 Boyer-Moore算法（工程常用）
实际文本编辑器中更常用的算法，从右向左比较：
python复制def strStr(haystack: str, needle: str) -> int:
L, n = len(needle), len(haystack)
if L == 0:
return 0
# 构建坏字符表
bad_char = {}
for i in range(L):
bad_char[needle[i]] = i
# 匹配过程
s = 0
while s <= n - L:
j = L - 1
while j >= 0 and haystack[s + j] == needle[j]:
j -= 1
if j == -1:
return s
else:
skip = j - bad_char.get(haystack[s + j], -1)
s += max(1, skip)
return -1
最好情况O(N/L)，最坏O(NL)。在字母表较大时表现优异。
算法选择建议：面试优先展示KMP，实际工程中短模式用暴力法，长文本用Boyer-Moore。Rabin-Karp适合多模式匹配场景。
4. 常见错误与调试技巧
4.1 翻转字符串的易错点
-
空格处理不完整：
- 忘记处理字符串中间的多余空格
- 反转后单词间应该保留单个空格但实际保留了多个
-
原地修改时的索引错误：
python复制# 错误示例：反转时左右指针交叉 while left <= right: # 应该用 < 而非 <= arr[left], arr[right] = arr[right], arr[left] left += 1 right -= 1 -
边界条件遗漏：
- 空字符串输入
- 全空格字符串
- 单个单词无空格情况
4.2 strStr()的调试要点
- needle为空时应返回0（题目约定）
- haystack比needle短时的快速返回
- 在实现KMP时next数组构建错误：
python复制# 常见错误：漏掉j回退逻辑 if needle[i] == needle[j]: j += 1 next[i] = j # 缺少else分支处理 - 暴力法中的索引越界：
python复制for i in range(len(haystack)): # 应该用len(haystack)-len(needle)+1 if haystack[i:i+len(needle)] == needle: return i
4.3 测试用例设计建议
对于翻转字符串：
- 常规案例："the sky is blue" → "blue is sky the"
- 前后有空格：" hello world " → "world hello"
- 多个连续空格："a good example" → "example good a"
- 单单词："hello" → "hello"
- 空字符串："" → ""
对于strStr():
- 正常匹配："hello", "ll" → 2
- 不匹配："aaaaa", "bba" → -1
- needle为空："" in "abc" → 0
- 完全匹配："abc", "abc" → 0
- 重复模式："mississippi", "issip" → 4
5. 算法优化与扩展思考
5.1 翻转字符串的工程实践
在实际项目中，我们可能需要处理更复杂的场景：
- 保留标点符号位置："Hello, world!" → "world! Hello,"
- 处理多语言字符（如中文、emoji）
- 超大字符串的内存优化版本
python复制# 支持中文和标点的改进版
def reverse_words_enhanced(s: str) -> str:
import re
words = re.findall(r'[\w\-\u4e00-\u9fff]+|[^\w\s]', s)
return ' '.join(reversed(words))
5.2 字符串匹配的进阶应用
掌握strStr()的各种算法后，可以解决更复杂的问题：
- 重复子串判断（LeetCode 459）
- 回文子串查找（可结合KMP）
- 多模式匹配（AC自动机）
- 正则表达式引擎实现基础
以重复子串判断为例：
python复制def repeatedSubstringPattern(s: str) -> bool:
return (s + s).find(s, 1) != len(s)
5.3 算法选择的时间/空间权衡
| 算法 | 预处理时间 | 匹配时间 | 空间复杂度 | 适用场景 |
|---|---|---|---|---|
| 暴力匹配 | O(1) | O((N-L)L) | O(1) | 短模式串 |
| KMP | O(L) | O(N) | O(L) | 长模式串，重复率高 |
| Boyer-Moore | O(L) | O(N) | O(L) | 大字母表，长文本 |
| Rabin-Karp | O(L) | O(N) | O(1) | 多模式匹配，流式处理 |
在实际开发中，Python的find()方法已经高度优化，通常比自己实现的算法更快。但理解这些原理对处理特殊场景和面试都至关重要。