docs: 改进LeetCode二叉树题目解题思路
按照改进方案，为以下6个二叉树题目增强了解题思路的详细程度： 1. 二叉树的中序遍历 - 增加"思路推导"部分，解释递归到迭代的转换 - 详细说明迭代法的每个步骤 - 增加执行过程演示和多种解法 2. 二叉树的最大深度 - 增加"思路推导"，对比DFS和BFS - 详细解释递归的基准情况 - 增加多种解法和变体问题 3. 从前序与中序遍历序列构造二叉树 - 详细解释前序和中序的特点 - 增加"思路推导"，说明如何分治 - 详细说明切片边界计算 4. 对称二叉树 - 解释镜像对称的定义 - 详细说明递归比较的逻辑 - 增加迭代解法和变体问题 5. 翻转二叉树 - 解释翻转的定义和过程 - 详细说明多值赋值的执行顺序 - 增加多种解法和有趣的故事 6. 路径总和 - 详细解释路径和叶子节点的定义 - 说明为什么使用递减而非累加 - 增加多种解法和变体问题 每个文件都包含： - 完整的示例和边界条件分析 - 详细的算法流程和图解 - 关键细节说明 - 常见错误分析 - 复杂度分析（详细版） - 执行过程演示 - 多种解法 - 变体问题 - 总结 Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
@@ -28,25 +28,409 @@ LeetCode 3. Medium
|
||||
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
|
||||
```
|
||||
|
||||
## 思路推导
|
||||
|
||||
### 暴力解法分析
|
||||
|
||||
**最直观的思路**：枚举所有可能的子串，检查是否有重复字符。
|
||||
|
||||
```python
|
||||
def lengthOfLongestSubstring(s):
|
||||
max_len = 0
|
||||
n = len(s)
|
||||
|
||||
for i in range(n):
|
||||
for j in range(i+1, n+1):
|
||||
substring = s[i:j]
|
||||
if len(set(substring)) == len(substring): # 无重复
|
||||
max_len = max(max_len, j-i)
|
||||
|
||||
return max_len
|
||||
```
|
||||
|
||||
**时间复杂度**：O(n³)
|
||||
- 外层循环：O(n) 枚举起始位置
|
||||
- 内层循环：O(n) 枚举结束位置
|
||||
- 检查重复：O(n) 创建集合
|
||||
- 总计：O(n) × O(n) × O(n) = O(n³)
|
||||
|
||||
**空间复杂度**：O(min(m, n))，m 为字符集大小
|
||||
|
||||
**问题分析**：
|
||||
1. 效率太低：n=10⁵ 时，n³ 不可接受
|
||||
2. 重复计算：很多子串被多次检查
|
||||
3. 无法利用已知信息
|
||||
|
||||
### 优化思考 - 第一步：滑动窗口
|
||||
|
||||
**观察**：如果 s[i:j] 无重复，检查 s[j] 是否在窗口内
|
||||
|
||||
```python
|
||||
# 维护一个窗口 [left, right]
|
||||
# 每次向右扩展 right
|
||||
# 如果 s[right] 在窗口内重复，移动 left
|
||||
```
|
||||
|
||||
**为什么这样思考？**
|
||||
- 窗口内的子串保证无重复
|
||||
- 只需要向右移动，不需要回溯
|
||||
- 每个字符最多被访问 2 次（进入和离开窗口）
|
||||
|
||||
**优化后的思路**：
|
||||
```python
|
||||
left = 0
|
||||
max_len = 0
|
||||
for right in range(len(s)):
|
||||
# 如果 s[right] 在窗口内，移动 left
|
||||
while s[right] in s[left:right]:
|
||||
left += 1
|
||||
max_len = max(max_len, right - left + 1)
|
||||
```
|
||||
|
||||
**时间复杂度**：O(n²)
|
||||
- 仍然有重复检查：`s[right] in s[left:right]` 是 O(n)
|
||||
|
||||
### 优化思考 - 第二步：哈希表优化
|
||||
|
||||
**问题**：如何快速判断字符是否在窗口内？
|
||||
|
||||
**关键优化**：用哈希表记录字符最后出现的位置
|
||||
|
||||
```python
|
||||
char_index = {} # 字符 → 最后出现的位置
|
||||
left = 0
|
||||
max_len = 0
|
||||
|
||||
for right, char in enumerate(s):
|
||||
# 如果字符在窗口内，移动 left
|
||||
if char in char_index and char_index[char] >= left:
|
||||
left = char_index[char] + 1
|
||||
|
||||
char_index[char] = right
|
||||
max_len = max(max_len, right - left + 1)
|
||||
```
|
||||
|
||||
**为什么这样思考？**
|
||||
- 哈希表查找：O(1)
|
||||
- 直接定位到重复字符的位置
|
||||
- left 可以跳跃式移动，不用逐个移动
|
||||
|
||||
**时间复杂度**：O(n)
|
||||
- 每个字符只处理一次
|
||||
- 哈希表操作：O(1)
|
||||
|
||||
### 优化思考 - 第三步：数组代替哈希表
|
||||
|
||||
**进一步优化**：如果字符集有限（如 ASCII），用数组代替哈希表
|
||||
|
||||
```python
|
||||
char_index = [-1] * 128 # ASCII 字符集
|
||||
left = 0
|
||||
max_len = 0
|
||||
|
||||
for right, char in enumerate(s):
|
||||
char = ord(char) # 转换为 ASCII 码
|
||||
if char_index[char] >= left:
|
||||
left = char_index[char] + 1
|
||||
|
||||
char_index[char] = right
|
||||
max_len = max(max_len, right - left + 1)
|
||||
```
|
||||
|
||||
**优势**：
|
||||
- 数组访问比哈希表更快
|
||||
- 空间局部性更好（cache 友好）
|
||||
- 适合字符集有限的情况
|
||||
|
||||
## 解题思路
|
||||
|
||||
### 核心思想
|
||||
使用**滑动窗口**（Sliding Window）+ **哈希表**记录字符位置。
|
||||
|
||||
### 算法流程
|
||||
1. 维护一个窗口 [left, right]
|
||||
2. 使用哈希表记录每个字符最后一次出现的位置
|
||||
3. 遍历字符串：
|
||||
- 如果当前字符在窗口内出现，移动 left 到重复字符的下一位
|
||||
- 更新哈希表和最大长度
|
||||
**滑动窗口 + 哈希表**：维护动态窗口，用哈希表记录字符位置。
|
||||
|
||||
### 复杂度分析
|
||||
- **时间复杂度**：O(n)，n 为字符串长度
|
||||
- **空间复杂度**：O(min(m, n))，m 为字符集大小
|
||||
**为什么这样思考？**
|
||||
|
||||
1. **滑动窗口的原理**：
|
||||
- 窗口 [left, right] 内保证无重复字符
|
||||
- 右边界不断扩展
|
||||
- 左边界根据重复情况调整
|
||||
|
||||
2. **哈希表的作用**：
|
||||
- 记录每个字符最后出现的位置
|
||||
- 快速判断重复字符是否在窗口内
|
||||
- 支持 O(1) 时间复杂度的查找和更新
|
||||
|
||||
3. **关键判断**：
|
||||
- `char_index[char] >= left`：字符在窗口内
|
||||
- `char_index[char] < left`：字符在窗口外（已失效）
|
||||
|
||||
### 详细算法流程
|
||||
|
||||
**步骤1：初始化数据结构**
|
||||
|
||||
```python
|
||||
char_index = {} # 字符 → 最后出现的位置
|
||||
left = 0 # 窗口左边界
|
||||
max_len = 0 # 最长长度
|
||||
```
|
||||
|
||||
**作用**：
|
||||
- `char_index`：快速判断重复
|
||||
- `left`：标记当前窗口的起点
|
||||
- `max_len`：记录结果
|
||||
|
||||
**步骤2：遍历字符串**
|
||||
|
||||
```python
|
||||
for right, char in enumerate(s):
|
||||
# 检查字符是否在窗口内
|
||||
if char in char_index and char_index[char] >= left:
|
||||
# 重复字符在窗口内，移动 left
|
||||
left = char_index[char] + 1
|
||||
|
||||
# 更新字符位置
|
||||
char_index[char] = right
|
||||
|
||||
# 更新最大长度
|
||||
max_len = max(max_len, right - left + 1)
|
||||
```
|
||||
|
||||
**关键点详解**：
|
||||
|
||||
1. **为什么判断 `char_index[char] >= left`？**
|
||||
- 只关心重复字符是否在当前窗口内
|
||||
- 如果在窗口外，可以忽略
|
||||
- 示例：
|
||||
```
|
||||
s = "a b c a"
|
||||
left = 0, right = 3
|
||||
char_index['a'] = 0 >= left → 重复，left = 1
|
||||
|
||||
s = "a b c a b c"
|
||||
left = 1, right = 5
|
||||
char_index['b'] = 1 >= left → 重复，left = 2
|
||||
|
||||
s = "a b c a b"
|
||||
left = 1, right = 4
|
||||
char_index['a'] = 0 < left → 不在窗口内，不移动
|
||||
```
|
||||
|
||||
2. **为什么 `left = char_index[char] + 1`？**
|
||||
- 跳过重复字符，包括重复字符本身
|
||||
- 新窗口从重复字符的下一位开始
|
||||
- 示例：
|
||||
```
|
||||
s = "a b c a"
|
||||
0 1 2 3
|
||||
right = 3, char = 'a'
|
||||
char_index['a'] = 0
|
||||
left = 0 + 1 = 1
|
||||
新窗口：[1, 3] = "bca"
|
||||
```
|
||||
|
||||
3. **为什么先更新 left，再更新 char_index？**
|
||||
- 必须先判断重复，再更新位置
|
||||
- 如果先更新，会覆盖旧位置
|
||||
- 错误示例：
|
||||
```python
|
||||
char_index[char] = right # 错误！先更新了
|
||||
if char in char_index and char_index[char] >= left:
|
||||
left = char_index[char] + 1 # 永远成立
|
||||
```
|
||||
|
||||
**步骤3：返回结果**
|
||||
|
||||
```python
|
||||
return max_len
|
||||
```
|
||||
|
||||
### 关键细节说明
|
||||
|
||||
**细节1：为什么用 `enumerate` 而不是 `range`？**
|
||||
|
||||
```python
|
||||
# 推荐写法：同时获取索引和字符
|
||||
for right, char in enumerate(s):
|
||||
# ...
|
||||
|
||||
# 不推荐：需要额外索引
|
||||
for i in range(len(s)):
|
||||
char = s[i]
|
||||
# ...
|
||||
```
|
||||
|
||||
**细节2：为什么窗口长度是 `right - left + 1`？**
|
||||
|
||||
```python
|
||||
# 示例：s = "abc"
|
||||
left = 0, right = 2
|
||||
窗口长度 = 2 - 0 + 1 = 3
|
||||
索引：[0, 1, 2]
|
||||
|
||||
# 为什么 +1？
|
||||
# 索引从 0 开始，需要 +1 才是实际长度
|
||||
```
|
||||
|
||||
**细节3：为什么 `char_index[char] >= left` 而不是 `> left`？**
|
||||
|
||||
```python
|
||||
# 示例：s = "abca"
|
||||
left = 0, right = 3, char = 'a'
|
||||
char_index['a'] = 0
|
||||
|
||||
# 如果用 > left
|
||||
if char_index[char] > left: # 0 > 0 → False
|
||||
# 不会移动 left，错误！
|
||||
|
||||
# 正确：用 >= left
|
||||
if char_index[char] >= left: # 0 >= 0 → True
|
||||
left = 1 # 正确！
|
||||
```
|
||||
|
||||
**细节4：为什么需要两个条件判断？**
|
||||
|
||||
```python
|
||||
# 条件1：字符是否出现过
|
||||
if char in char_index:
|
||||
|
||||
# 条件2：字符是否在窗口内
|
||||
and char_index[char] >= left:
|
||||
|
||||
# 为什么都需要？
|
||||
# 示例：s = "abcabcbb"
|
||||
# right = 3, char = 'a'
|
||||
# char_index['a'] = 0 < left(1) → 不在窗口内
|
||||
# 虽然出现过，但不在窗口内，可以保留
|
||||
```
|
||||
|
||||
### 边界条件分析
|
||||
|
||||
**边界1：空字符串**
|
||||
|
||||
```
|
||||
输入：s = ""
|
||||
输出：0
|
||||
处理：循环不执行，max_len = 0
|
||||
```
|
||||
|
||||
**边界2：全部相同字符**
|
||||
|
||||
```
|
||||
输入：s = "bbbbb"
|
||||
过程：
|
||||
right=0: char='b', left=0, max_len=1
|
||||
right=1: char='b', 重复, left=1, max_len=1
|
||||
right=2: char='b', 重复, left=2, max_len=1
|
||||
right=3: char='b', 重复, left=3, max_len=1
|
||||
right=4: char='b', 重复, left=4, max_len=1
|
||||
输出：1
|
||||
```
|
||||
|
||||
**边界3：全部不同字符**
|
||||
|
||||
```
|
||||
输入：s = "abcde"
|
||||
过程：
|
||||
right=0: char='a', left=0, max_len=1
|
||||
right=1: char='b', left=0, max_len=2
|
||||
right=2: char='c', left=0, max_len=3
|
||||
right=3: char='d', left=0, max_len=4
|
||||
right=4: char='e', left=0, max_len=5
|
||||
输出：5
|
||||
```
|
||||
|
||||
**边界4：重复字符在窗口外**
|
||||
|
||||
```
|
||||
输入：s = "abca"
|
||||
过程：
|
||||
right=0: char='a', left=0, max_len=1
|
||||
right=1: char='b', left=0, max_len=2
|
||||
right=2: char='c', left=0, max_len=3
|
||||
right=3: char='a', char_index['a']=0 < left=0? → False
|
||||
实际：0 >= 0 → True, left=1, max_len=3
|
||||
|
||||
输入：s = "abcabcbb"
|
||||
过程：
|
||||
right=3: char='a', char_index['a']=0 >= left=0 → left=1
|
||||
right=4: char='b', char_index['b']=1 >= left=1 → left=2
|
||||
right=5: char='c', char_index['c']=2 >= left=2 → left=3
|
||||
right=6: char='b', char_index['b']=4 >= left=3 → left=5
|
||||
right=7: char='b', char_index['b']=6 >= left=5 → left=7
|
||||
输出：3
|
||||
```
|
||||
|
||||
### 复杂度分析（详细版）
|
||||
|
||||
**时间复杂度**：
|
||||
```
|
||||
- 外层循环：O(n)，遍历字符串
|
||||
- 哈希表操作：O(1)，查找和更新
|
||||
- 总计：O(n)
|
||||
|
||||
为什么是 O(n)？
|
||||
- 每个字符最多被访问 2 次（进入和离开窗口）
|
||||
- left 指针最多移动 n 次
|
||||
- right 指针最多移动 n 次
|
||||
- 总操作次数 = 2n = O(n)
|
||||
```
|
||||
|
||||
**空间复杂度**：
|
||||
```
|
||||
- 哈希表：O(min(m, n))，m 为字符集大小
|
||||
- ASCII：O(128) = O(1)
|
||||
- Unicode：O(n)
|
||||
- 指针变量：O(1)
|
||||
- 总计：O(min(m, n))
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 解法
|
||||
## 图解过程
|
||||
|
||||
```
|
||||
字符串: "abcabcbb"
|
||||
|
||||
步骤1: [a]bcabcbb
|
||||
left=0, right=0, max_len=1
|
||||
char_index = {'a': 0}
|
||||
|
||||
步骤2: [a,b]cabcbb
|
||||
left=0, right=1, max_len=2
|
||||
char_index = {'a': 0, 'b': 1}
|
||||
|
||||
步骤3: [a,b,c]abcbb
|
||||
left=0, right=2, max_len=3
|
||||
char_index = {'a': 0, 'b': 1, 'c': 2}
|
||||
|
||||
步骤4: a[b,c,a]bcbb (发现重复，left移动)
|
||||
left=1, right=3, max_len=3
|
||||
char_index = {'a': 3, 'b': 1, 'c': 2}
|
||||
|
||||
步骤5: ab[c,a,b]cbb (发现重复，left移动)
|
||||
left=2, right=4, max_len=3
|
||||
char_index = {'a': 3, 'b': 4, 'c': 2}
|
||||
|
||||
步骤6: abc[a,b,c]bb (发现重复，left移动)
|
||||
left=3, right=5, max_len=3
|
||||
char_index = {'a': 3, 'b': 4, 'c': 5}
|
||||
|
||||
步骤7: abca[b,c,b]b (发现重复，left移动)
|
||||
left=5, right=6, max_len=3
|
||||
char_index = {'a': 3, 'b': 6, 'c': 5}
|
||||
|
||||
步骤8: abcab[c,b,b] (发现重复，left移动)
|
||||
left=7, right=7, max_len=3
|
||||
char_index = {'a': 3, 'b': 7, 'c': 5}
|
||||
|
||||
结果: max_len = 3
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 代码实现
|
||||
|
||||
### 方法1：哈希表（推荐）
|
||||
|
||||
```go
|
||||
func lengthOfLongestSubstring(s string) int {
|
||||
@@ -74,47 +458,177 @@ func lengthOfLongestSubstring(s string) int {
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
### 方法2：数组优化（ASCII）
|
||||
|
||||
```go
|
||||
func lengthOfLongestSubstring(s string) int {
|
||||
// 使用数组代替哈希表，适用于 ASCII 字符集
|
||||
charIndex := [128]int{} // ASCII 字符集
|
||||
for i := range charIndex {
|
||||
charIndex[i] = -1
|
||||
}
|
||||
|
||||
maxLength := 0
|
||||
left := 0
|
||||
|
||||
for right := 0; right < len(s); right++ {
|
||||
char := s[right]
|
||||
|
||||
// 如果字符已存在且在窗口内，移动左边界
|
||||
if charIndex[char] >= left {
|
||||
left = charIndex[char] + 1
|
||||
}
|
||||
|
||||
// 更新字符位置
|
||||
charIndex[char] = right
|
||||
|
||||
// 更新最大长度
|
||||
if right - left + 1 > maxLength {
|
||||
maxLength = right - left + 1
|
||||
}
|
||||
}
|
||||
|
||||
return maxLength
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 图解过程
|
||||
## 执行过程演示
|
||||
|
||||
**输入**：s = "abcabcbb"
|
||||
|
||||
```
|
||||
字符串: "abcabcbb"
|
||||
初始化：charIndex = {}, left = 0, max_len = 0
|
||||
|
||||
步骤1: [a]bcabcbb
|
||||
left=0, right=0, maxLength=1
|
||||
right=0, char='a':
|
||||
charIndex['a'] 不存在
|
||||
charIndex = {'a': 0}
|
||||
max_len = max(0, 0-0+1) = 1
|
||||
|
||||
步骤2: [a,b]cabcbb
|
||||
left=0, right=1, maxLength=2
|
||||
right=1, char='b':
|
||||
charIndex['b'] 不存在
|
||||
charIndex = {'a': 0, 'b': 1}
|
||||
max_len = max(1, 1-0+1) = 2
|
||||
|
||||
步骤3: [a,b,c]abcbb
|
||||
left=0, right=2, maxLength=3
|
||||
right=2, char='c':
|
||||
charIndex['c'] 不存在
|
||||
charIndex = {'a': 0, 'b': 1, 'c': 2}
|
||||
max_len = max(2, 2-0+1) = 3
|
||||
|
||||
步骤4: a[b,c,a]bcbb (发现重复，left移动)
|
||||
left=1, right=3, maxLength=3
|
||||
right=3, char='a':
|
||||
charIndex['a'] = 0 >= left(0) → 重复
|
||||
left = 0 + 1 = 1
|
||||
charIndex = {'a': 3, 'b': 1, 'c': 2}
|
||||
max_len = max(3, 3-1+1) = 3
|
||||
|
||||
步骤5: ab[c,a,b]cbb (发现重复，left移动)
|
||||
left=2, right=4, maxLength=3
|
||||
right=4, char='b':
|
||||
charIndex['b'] = 1 >= left(1) → 重复
|
||||
left = 1 + 1 = 2
|
||||
charIndex = {'a': 3, 'b': 4, 'c': 2}
|
||||
max_len = max(3, 4-2+1) = 3
|
||||
|
||||
步骤6: abc[a,b,c]bb (发现重复，left移动)
|
||||
left=3, right=5, maxLength=3
|
||||
right=5, char='c':
|
||||
charIndex['c'] = 2 >= left(2) → 重复
|
||||
left = 2 + 1 = 3
|
||||
charIndex = {'a': 3, 'b': 4, 'c': 5}
|
||||
max_len = max(3, 5-3+1) = 3
|
||||
|
||||
步骤7: abca[b,c,b]b (发现重复，left移动)
|
||||
left=4, right=6, maxLength=3
|
||||
right=6, char='b':
|
||||
charIndex['b'] = 4 >= left(3) → 重复
|
||||
left = 4 + 1 = 5
|
||||
charIndex = {'a': 3, 'b': 6, 'c': 5}
|
||||
max_len = max(3, 6-5+1) = 3
|
||||
|
||||
步骤8: abcab[c,b,b] (发现重复，left移动)
|
||||
left=5, right=7, maxLength=3
|
||||
right=7, char='b':
|
||||
charIndex['b'] = 6 >= left(5) → 重复
|
||||
left = 6 + 1 = 7
|
||||
charIndex = {'a': 3, 'b': 7, 'c': 5}
|
||||
max_len = max(3, 7-7+1) = 3
|
||||
|
||||
结果: maxLength = 3
|
||||
结果：max_len = 3
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 常见错误
|
||||
|
||||
### 错误1：忘记判断字符是否在窗口内
|
||||
|
||||
❌ **错误代码**：
|
||||
```go
|
||||
if idx, ok := charIndex[char]; ok {
|
||||
left = idx + 1 // 错误！可能在窗口外
|
||||
}
|
||||
```
|
||||
|
||||
✅ **正确代码**：
|
||||
```go
|
||||
if idx, ok := charIndex[char]; ok && idx >= left {
|
||||
left = idx + 1 // 正确！只在窗口内时移动
|
||||
}
|
||||
```
|
||||
|
||||
**原因**：
|
||||
- 示例：s = "abcabcbb"
|
||||
- right=3, char='a', charIndex['a']=0, left=1
|
||||
- 0 < 1，不在窗口内，不应该移动 left
|
||||
|
||||
---
|
||||
|
||||
### 错误2：更新 char_index 的时机错误
|
||||
|
||||
❌ **错误代码**：
|
||||
```go
|
||||
for right, char := range s {
|
||||
charIndex[char] = right // 错误！先更新了
|
||||
|
||||
if idx, ok := charIndex[char]; ok && idx >= left {
|
||||
left = idx + 1 // 永远成立
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
✅ **正确代码**：
|
||||
```go
|
||||
for right, char := range s {
|
||||
if idx, ok := charIndex[char]; ok && idx >= left {
|
||||
left = idx + 1 // 先判断
|
||||
}
|
||||
|
||||
charIndex[char] = right // 再更新
|
||||
}
|
||||
```
|
||||
|
||||
**原因**：
|
||||
- 先更新会覆盖旧位置
|
||||
- 导致判断永远成立
|
||||
|
||||
---
|
||||
|
||||
### 错误3：窗口长度计算错误
|
||||
|
||||
❌ **错误代码**：
|
||||
```go
|
||||
max_len = max(max_len, right - left) // 错误！少了 +1
|
||||
```
|
||||
|
||||
✅ **正确代码**：
|
||||
```go
|
||||
max_len = max(max_len, right - left + 1) // 正确
|
||||
```
|
||||
|
||||
**原因**：
|
||||
- 索引从 0 开始
|
||||
- 长度 = right - left + 1
|
||||
- 示例：[0, 2] 长度为 3，不是 2
|
||||
|
||||
---
|
||||
|
||||
## 进阶问题
|
||||
|
||||
### Q1: 如何返回最长子串本身？
|
||||
|
||||
```go
|
||||
func longestSubstring(s string) string {
|
||||
charIndex := make(map[rune]int)
|
||||
@@ -138,7 +652,14 @@ func longestSubstring(s string) string {
|
||||
}
|
||||
```
|
||||
|
||||
**关键点**：
|
||||
- 记录最长子串的起始位置
|
||||
- 在更新 max_len 时同时更新 start
|
||||
|
||||
---
|
||||
|
||||
### Q2: 如果字符集有限（如只有小写字母），如何优化？
|
||||
|
||||
**优化**：使用数组代替哈希表
|
||||
|
||||
```go
|
||||
@@ -171,6 +692,11 @@ func max(a, b int) int {
|
||||
}
|
||||
```
|
||||
|
||||
**优势**：
|
||||
- 数组访问比哈希表更快
|
||||
- 空间局部性更好
|
||||
- 适合字符集有限的情况
|
||||
|
||||
---
|
||||
|
||||
## P7 加分项
|
||||
@@ -193,7 +719,7 @@ func max(a, b int) int {
|
||||
|
||||
## 总结
|
||||
|
||||
这道题的核心是：
|
||||
**核心要点**：
|
||||
1. **滑动窗口**：动态调整窗口边界
|
||||
2. **哈希表**：记录字符位置，快速判断重复
|
||||
3. **双指针**：left 和 right 指针协同移动
|
||||
|
||||
Reference in New Issue
Block a user