Todo · 我的个人知识库

Table of Contents

🚀 快速复习（年后恢复记忆） #

⚡ 5分钟核心记忆点 #

1️⃣ 双指针（必记） #

快慢指针：slow 标记有效区域，fast 遍历
对撞指针：left=0, right=len-1，向中间移动
易错：slow 从 0 开始，不是 1

2️⃣ 滑动窗口（必记） #

left = 0
for right in range(len(s)):
    window.add(s[right])
    while 不满足条件:
        window.remove(s[left])
        left += 1
    更新答案

易错：用 nums[left] 作为 key，不是 left 本身

3️⃣ 单调栈（必记） #

stack = []
for i in range(len(nums)):
    while stack and nums[i] > nums[stack[-1]]:  # 递减栈用 >
        prev = stack.pop()
        ans[prev] = nums[i]  # 或 i - prev
    stack.append(i)

易错：ans[prev_index] 不是 ans[i]
递增栈：找左边第一个更小的，用 <

4️⃣ 哈希表（必记） #

两数之和：seen[num] = i 存索引
最长连续序列：num-1 not in set 找起点，然后 while num+1 in set 计数

5️⃣ 栈（必记） #

有效括号：只压左括号，遇到右括号立即匹配栈顶
字符串解码：栈存 (num, str) 对，遇 [ 存档，遇 ] 出栈

6️⃣ 链表（必记） #

反转：三指针 prev, curr, next_node
删除倒数第N个：快指针先走 n+1 步
环形链表II：相遇后，一个从头，一个从相遇点，同时走

7️⃣ 二叉树（必记） #

def dfs(root):
    if not root:
        return 边界值
    left = dfs(root.left)
    right = dfs(root.right)
    return 处理当前节点

8️⃣ 回溯（必记） #

def backtrack(path):
    if 满足条件:
        result.append(path[:])  # 注意深拷贝
        return
    for choice in choices:
        path.append(choice)
        backtrack(path)
        path.pop()  # 回溯

9️⃣ 动态规划（必记） #

最大子数组和：dp[i] = max(nums[i], dp[i-1] + nums[i])
打家劫舍：dp[i] = max(dp[i-1], dp[i-2] + nums[i])
最长递增子序列：dp[i] = max(dp[j]) + 1 (j < i 且 nums[j] < nums[i])

🔟 二分查找（必记） #

left, right = 0, len(nums) - 1
while left <= right:
    mid = (left + right) // 2
    if nums[mid] == target:
        return mid
    elif nums[mid] < target:
        left = mid + 1
    else:
        right = mid - 1

🔴 必须重做的错题（按优先级） #

84. 柱状图中最大的矩形 - 单调递增栈 + 哨兵
76. 最小覆盖子串 - valid 计数逻辑
128. 最长连续序列 - num-1 not in set 找起点
394. 字符串解码 - 栈存 (num, str) 对
15. 三数之和 - 三处去重逻辑
20. 有效的括号 - 只压左括号，右括号立即匹配

💡 面试话术（30秒内说出） #

拿到题目：“我先理解题意…思路是…时间复杂度O(n)，空间O(1)，您看可以吗？”
写代码前：“我先画个图…关键点是…”
写完代码：“我用示例测试…边界情况是…”
优化：“暴力O(n²)，可以用XX优化到O(n)，trade-off是空间从O(1)变成O(n)”

🔥 百度测开明日冲刺（考前必看） #

✅ 已掌握的高频题（放心题） #

题号	题目	状态	快速回忆
206	反转链表	✅	三指针：`prev, curr, next_node`
3	无重复字符最长子串	✅	`set` + `while` 收缩
21	合并两个有序链表	✅	哨兵节点
1	两数之和	✅	`seen[num] = i` 存索引
155	最小栈	✅	双栈同步

🟡 需要快速复习（1小时） #

题号	题目	复习要点	代码模板
20	有效的括号	只压左括号，右括号立即匹配	见下方
141	环形链表	快慢指针 + HashMap两种方法	见下方
198	打家劫舍	`dp[i] = max(dp[i-1], dp[i-2]+nums[i])`	见下方
53	最大子数组和	`dp[i] = max(nums[i], dp[i-1]+nums[i])`	见下方

🔴 没做过但可能考（2小时快速刷） #

题号	题目	快速要点
121	买卖股票I	`minPrice` + `maxProfit`
5	最长回文子串	中心扩展或DP
55	跳跃游戏	贪心：维护最远可达位置
74	搜索二维矩阵	右上角开始 O(m+n)
94	二叉树中序遍历	递归 + 迭代（栈）
144	二叉树先序遍历	递归 + 迭代（栈）

📝 百度测开核心代码模板（考前背诵） #

1. 有效的括号（20）⭐⭐⭐⭐⭐ #

def isValid(s: str) -> bool:
    # 边界：空字符串
    if not s:
        return True
    
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    
    for char in s:
        if char in mapping:  # 右括号
            # 边界：栈为空或不匹配
            if not stack or stack.pop() != mapping[char]:
                return False
        else:  # 左括号
            stack.append(char)
    
    # 边界：栈还有剩余
    return len(stack) == 0

测试用例（测开必问）：

"" → True
"(" → False
"()[]{}"→ True
"([)]" → False

2. 环形链表（141）⭐⭐⭐⭐ #

# 方法1：HashMap
def hasCycle(head):
    seen = set()
    while head:
        if head in seen:
            return True
        seen.add(head)
        head = head.next
    return False

# 方法2：快慢指针（推荐）
def hasCycle(head):
    if not head or not head.next:
        return False
    
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

测试用例：

None → False
1 → False
1→2→3→2（环）→ True

3. 打家劫舍（198）⭐⭐⭐⭐ #

def rob(nums):
    # 边界
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    
    # dp[i] = 偷到第i家的最大金额
    prev2 = nums[0]
    prev1 = max(nums[0], nums[1])
    
    for i in range(2, len(nums)):
        curr = max(prev1, prev2 + nums[i])
        prev2 = prev1
        prev1 = curr
    
    return prev1

测试用例：

[] → 0
[1] → 1
[1,2,3,1] → 4
[2,7,9,3,1] → 12

4. 最大子数组和（53）⭐⭐⭐ #

def maxSubArray(nums):
    # 边界
    if not nums:
        return 0
    
    max_sum = curr_sum = nums[0]
    
    for i in range(1, len(nums)):
        curr_sum = max(nums[i], curr_sum + nums[i])
        max_sum = max(max_sum, curr_sum)
    
    return max_sum

测试用例：

[-2,1,-3,4,-1,2,1,-5,4] → 6
[1] → 1
[-1] → -1

5. 买卖股票I（121）⭐⭐⭐ #

def maxProfit(prices):
    if not prices:
        return 0
    
    min_price = prices[0]
    max_profit = 0
    
    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)
    
    return max_profit

6. 跳跃游戏（55）⭐⭐⭐ #

def canJump(nums):
    if not nums:
        return False
    
    max_reach = 0
    for i in range(len(nums)):
        if i > max_reach:  # 当前位置不可达
            return False
        max_reach = max(max_reach, i + nums[i])
        if max_reach >= len(nums) - 1:
            return True
    return True

7. 搜索二维矩阵（74）⭐⭐⭐ #

def searchMatrix(matrix, target):
    if not matrix or not matrix[0]:
        return False
    
    # 从右上角开始
    row, col = 0, len(matrix[0]) - 1
    
    while row < len(matrix) and col >= 0:
        if matrix[row][col] == target:
            return True
        elif matrix[row][col] > target:
            col -= 1  # 向左
        else:
            row += 1  # 向下
    
    return False

8. 二叉树中序遍历（94）⭐⭐⭐ #

# 递归
def inorderTraversal(root):
    if not root:
        return []
    return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right)

# 迭代（栈）
def inorderTraversal(root):
    res, stack = [], []
    curr = root
    
    while curr or stack:
        # 一路向左
        while curr:
            stack.append(curr)
            curr = curr.left
        # 弹出并访问
        curr = stack.pop()
        res.append(curr.val)
        # 转向右子树
        curr = curr.right
    
    return res

9. 二叉树先序遍历（144）⭐⭐⭐ #

# 递归
def preorderTraversal(root):
    if not root:
        return []
    return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)

# 迭代（栈）
def preorderTraversal(root):
    if not root:
        return []
    
    res, stack = [], [root]
    
    while stack:
        node = stack.pop()
        res.append(node.val)
        # 先压右子树（栈是后进先出）
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    
    return res

10. 最长回文子串（5）⭐⭐⭐ #

def longestPalindrome(s):
    if not s:
        return ""
    
    def expandAroundCenter(left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return right - left - 1
    
    start = end = 0
    for i in range(len(s)):
        # 奇数长度
        len1 = expandAroundCenter(i, i)
        # 偶数长度
        len2 = expandAroundCenter(i, i + 1)
        max_len = max(len1, len2)
        
        if max_len > end - start:
            start = i - (max_len - 1) // 2
            end = i + max_len // 2
    
    return s[start:end + 1]

🎯 明日面试策略（必看） #

⏰ 时间分配（假设45分钟面试） #

理解题意（2分钟）：复述题目，确认输入输出
说出思路（3分钟）：说算法+复杂度，等面试官确认
写代码（20分钟）：边写边说，不要闷头写
测试用例（10分钟）：重点！ 主动说边界条件
优化讨论（10分钟）：时间空间trade-off

🧪 测开必问边界条件（背下来） #

数组/字符串：

空数组 [] / 空字符串 ""
单元素 [1] / "a"
全部相同 [1,1,1] / "aaa"
负数 [-1,-2,-3]

链表：

空链表 None
单节点 1→None
两个节点 1→2→None

二叉树：

空树 None
只有根节点
只有左子树/右子树

特殊值：

整数溢出
重复元素
极端大小（0, 10^9）

💬 面试话术（考前背诵） #

拿到题目：

“我理解这道题是…（复述）…输入是…输出是…对吗？”

说思路：

“我想用XX算法，核心思路是…时间复杂度O(n)，空间O(1)，您看这个方向可以吗？”

写完代码：

“我先测试几个用例…（主动说边界）：空数组返回0，单元素返回它本身，正常情况…”

面试官提醒边界：

“好的，我考虑一下这个边界…（思考并补充代码）…这样处理应该可以覆盖这种情况”

📚 考前30分钟速记清单 #

链表 #

反转：prev, curr, next_node = None, head, None
判环：slow=fast=head，fast走两步

栈 #

括号匹配：只压左括号
单调栈：while stack and nums[i] > nums[stack[-1]]

DP #

打家劫舍：max(prev1, prev2 + nums[i])
最大子数组：max(nums[i], curr_sum + nums[i])

贪心 #

买股票：维护最小价格
跳跃游戏：维护最远位置

二叉树 #

先序：根→左→右
中序：左→根→右
迭代：用栈模拟递归

📊 已完成题目总结（基于 window.py） #

✅ 双指针系列（7题） #

题号	题目	状态	核心要点
26	删除有序数组中的重复项	✅	快慢指针，slow 标记有效区域
283	移动零	✅	快慢指针，最后填充 0
80	删除重复项 II	✅	`nums[fast] != nums[slow-1]`
167	两数之和 II	✅	对撞双指针
15	三数之和	🔄	排序 + 双指针 + 三处去重（需复习）
18	四数之和	🔄	嵌套循环 + 双指针（需复习）

错题记录：

removeZero：slow 初始化错误（应该从 0 开始）
fourSum：语法错误（nums.sorted() 应为 nums.sort()）

✅ 滑动窗口系列（5题） #

题号	题目	状态	核心要点
3	无重复字符的最长子串	✅	`set` + `while` 收缩
209	长度最小的子数组	✅	变量 `sum` + `while s >= target`
438	找到字符串中所有字母异位词	🔄	`Counter` 比较（需复习）
904	水果成篮	🔄	`dict` 记录种类，`len(seen) > 2` 收缩
76	最小覆盖子串	🔄	`valid` 计数 + `Counter`（需复习）

错题记录：

ll：res 更新位置错误（应在 while 外）
fruist：用 left/right 作为 key，应该用 nums[left/right]

✅ 哈希表系列（4题） #

题号	题目	状态	核心要点
1	两数之和	✅	`seen[num] = i` 存索引
202	快乐数	✅	`set` 检测循环
128	最长连续序列	🔄	`num-1 not in set` 找起点（需复习）
242	有效的字母异位词	✅	`Counter` 或 `sorted`

错题记录：

longgestNums：逻辑混乱，缺少 while 循环计数

✅ 栈系列（5题） #

题号	题目	状态	核心要点
20	有效的括号	🔄	右括号匹配栈顶（需复习逻辑）
155	最小栈	✅	双栈同步，`min_st` 存快照
394	字符串解码	🔄	栈存 `(num, str)`，遇 `[` 存档（需复习）
739	每日温度	🔄	单调递减栈，`ans[prev] = i - prev`（需复习）
503	下一个更大元素 II	✅	循环数组，`i % n`，跑两圈
84	柱状图中最大的矩形	❌	单调递增栈 + 哨兵（未完成）

错题记录：

validComma：逻辑错误，应该只压左括号，右括号匹配时立即判断
decode_str：isdigit(char) 语法错误，应为 char.isdigit()
dailyT：ans[i] 应为 ans[prev_index]
max_area：> 应为 <，宽度公式错误

🔄 链表系列（进行中） #

题号	题目	状态	核心要点
206	反转链表	✅	三指针：`prev, curr, next_node`
21	合并两个有序链表	✅	哨兵节点 + `current.next = l1`
19	删除倒数第 N 个节点	✅	快指针先走 `n+1` 步

🎯 面试 1 冲刺计划（4 天） #

Day 1：链表收尾 + 堆/优先队列 #

上午（2h）：链表

141. 环形链表（快慢指针判环）
142. 环形链表 II（数学推导：相遇后一个从头，一个从相遇点）
2. 两数相加（进位处理：carry = (val1 + val2 + carry) // 10）

下午（2h）：堆（必补）

215. 数组中的第 K 个最大元素（快速选择 or 小顶堆）
23. 合并 K 个升序链表（优先队列 or 分治）

晚上（1h）：复习

84. 柱状图中最大的矩形（修正错误）

Python heapq 速查：

import heapq
heapq.heappush(heap, item)  # 入堆
heapq.heappop(heap)          # 出堆（最小值）
heapq.heapify(list)          # 原地堆化
# 注意：Python 只有小顶堆，大顶堆需要取负数

Day 2：二叉树核心 #

上午（2.5h）：遍历 + 路径

94. 二叉树的中序遍历（递归 + 迭代）
102. 二叉树的层序遍历（BFS，用 deque）
104. 二叉树的最大深度（递归：max(left, right) + 1）
112. 路径总和（递归：sum - node.val）
236. 最近公共祖先（递归：左右都找到返回 root）

下午（2h）：构造 + 其他

105. 从前序与中序构造二叉树（递归分治）
226. 翻转二叉树（递归：交换左右子树）
101. 对称二叉树（递归：left.left == right.right）

二叉树递归模板：

def dfs(root):
    if not root:
        return 边界值
    left = dfs(root.left)
    right = dfs(root.right)
    return 当前层的处理逻辑

Day 3：动态规划入门 + 二分查找 #

上午（2.5h）：DP 高频

53. 最大子数组和（dp[i] = max(nums[i], dp[i-1] + nums[i])）
152. 乘积最大子数组（维护 max_prod 和 min_prod）
300. 最长递增子序列（dp[i] = max(dp[j]) + 1）
198. 打家劫舍（dp[i] = max(dp[i-1], dp[i-2] + nums[i])）

下午（2h）：二分查找

33. 搜索旋转排序数组（判断哪边有序）
153. 寻找旋转排序数组中的最小值（nums[mid] > nums[right]）
34. 查找元素的第一个和最后一个位置（两次二分）

二分查找模板：

left, right = 0, len(nums) - 1
while left <= right:
    mid = (left + right) // 2
    if nums[mid] == target:
        return mid
    elif nums[mid] < target:
        left = mid + 1
    else:
        right = mid - 1

Day 4：回溯 + DFS/BFS + 设计题 #

上午（2h）：回溯

46. 全排列（used 数组标记）
78. 子集（每个元素选或不选）
39. 组合总和（可重复选取，start 不变）

下午（2h）：搜索 + 设计

200. 岛屿数量（DFS 标记为 ‘0’）
207. 课程表（拓扑排序，BFS + 入度）
146. LRU 缓存（哈希表 + 双向链表）

晚上（1h）：模拟面试

随机抽 2 道 Medium，限时 40 分钟

回溯模板：

def backtrack(path, choices):
    if 满足条件:
        result.append(path[:])
        return
    for choice in choices:
        path.append(choice)
        backtrack(path, 新的choices)
        path.pop()  # 回溯

🚀 面试 2 冲刺计划（10 天） #

Day 5：链表 Hard + 排序 #

上午（2.5h）：

25. K 个一组翻转链表（分组反转 + 重连）
138. 复制带随机指针的链表（哈希表映射）
148. 排序链表（归并排序，快慢指针找中点）

下午（2h）：

56. 合并区间（排序 + 贪心）
75. 颜色分类（三路快排，荷兰国旗）

Day 6：动态规划进阶 #

上午（2.5h）：

322. 零钱兑换（完全背包）
139. 单词拆分（dp[i] = dp[j] and s[j:i] in wordDict）
221. 最大正方形（dp[i][j] = min(上,左,左上) + 1）
72. 编辑距离（三种操作：增删改）

下午（2h）：

213. 打家劫舍 II（环形，拆成两个链）
121/122. 买卖股票 I/II

Day 7：单调队列 + 前缀和 + 贪心 #

上午（2h）：单调队列

239. 滑动窗口最大值（单调递减队列，存索引）
862. 和至少为 K 的最短子数组

下午（2h）：

560. 和为 K 的子数组（前缀和 + 哈希表）
238. 除自身以外数组的乘积（前缀积 + 后缀积）
55/45. 跳跃游戏 I/II

Day 8：回溯进阶 + DFS/BFS #

上午（2.5h）：

47. 全排列 II（排序 + 去重）
90. 子集 II（排序 + 去重）
40. 组合总和 II（排序 + 去重）
131. 分割回文串

下午（2h）：

127. 单词接龙（BFS 最短路径）
79. 单词搜索（DFS + 回溯）
994. 腐烂的橘子（多源 BFS）

Day 9：二叉树 Hard + 设计题 #

上午（2.5h）：

124. 二叉树中的最大路径和（后序遍历）
297. 二叉树的序列化与反序列化
114. 二叉树展开为链表（前序遍历）
98. 验证二叉搜索树（中序遍历递增）

下午（2h）：

460. LFU 缓存（三个哈希表）
380. O(1) 时间插入删除和获取随机元素

Day 10：栈/队列补充 + 并查集 #

上午（2h）：

42. 接雨水（单调递减栈）
85. 最大矩形（单调栈 + DP）

下午（2h）：

547. 省份数量（并查集模板）
684. 冗余连接

Day 11-12：字节高频变形题 #

版本号排序（split('.') + 自定义比较）
小于 N 的最大数（贪心 + 回溯）
生产者消费者模式（threading + queue.Queue）
滑动窗口限流器（单调队列 + 时间戳）
线程安全的单例模式（双重检查锁）

Day 13：模拟面试 1 #

2 道 Medium + 1 道 Hard，限时 1.5 小时
复习错题，整理"一句话灵感"

Day 14：模拟面试 2 + 总复习 #

2 道 Medium + 1 道 Hard，限时 1.5 小时
复习所有题目，准备面试话术

📝 错题复习清单 #

🔴 高优先级（必须重做 3 遍） #

84. 柱状图中最大的矩形 - 单调递增栈 + 哨兵
76. 最小覆盖子串 - valid 计数逻辑
128. 最长连续序列 - num-1 not in set 找起点
394. 字符串解码 - 栈存 (num, str) 对
15. 三数之和 - 三处去重逻辑
20. 有效的括号 - 只压左括号，右括号立即匹配

🟡 中优先级（复习 2 遍） #

739. 每日温度 - ans[prev_index] 不是 ans[i]
438. 找到字符串中所有字母异位词 - 固定窗口 + Counter
904. 水果成篮 - nums[left] 作为 key，不是 left
18. 四数之和 - 四处去重 + 剪枝

🟢 低优先级（看一遍即可） #

283. 移动零 - 最后填充 0
202. 快乐数 - while n != 1 and n not in seen

🎯 面试话术模板 #

1. 拿到题目后（30 秒思考） #

“我先理解一下题意…（复述题目）…我想到的思路是…（说出算法）…时间复杂度是 O(n)，空间复杂度是 O(1)，您看这个方向可以吗？”

2. 写代码前（画图） #

“我先画个图帮助理解…（在纸上画示例）…这里的关键点是…（指出核心逻辑）”

3. 写完代码后（主动测试） #

“我用示例测试一下…（手动跑一遍）…边界情况是…（说出 corner case）”

4. 面试官追问优化 #

“暴力解法是 O(n²)，可以用…（数据结构/算法）优化到 O(n)，trade-off 是空间复杂度从 O(1) 变成 O(n)”

📚 核心模板速查 #

双指针 #

# 对撞双指针
left, right = 0, len(nums) - 1
while left < right:
    if 满足条件:
        记录答案
    移动指针

# 快慢指针
slow = fast = 0
while fast < len(nums):
    if 满足条件:
        slow += 1
    fast += 1

滑动窗口 #

left = 0
for right in range(len(s)):
    window.add(s[right])  # 扩大窗口
    while 不满足条件:
        window.remove(s[left])  # 收缩窗口
        left += 1
    更新答案

单调栈 #

stack = []
for i in range(len(nums)):
    while stack and nums[i] > nums[stack[-1]]:
        prev = stack.pop()
        ans[prev] = nums[i]  # 或 i - prev
    stack.append(i)

二叉树递归 #

def dfs(root):
    if not root:
        return 边界值
    left = dfs(root.left)
    right = dfs(root.right)
    return 处理当前节点

回溯 #

def backtrack(path):
    if 满足条件:
        result.append(path[:])
        return
    for choice in choices:
        path.append(choice)
        backtrack(path)
        path.pop()

🚨 百度测开12小时冲刺计划（立即执行！） #

⏰ 时间分配（共12小时） #

有效学习：5小时（分3个时间段）
睡眠：6小时（必须保证！）
其他：1小时（吃饭、休息、洗漱）

📅 具体时间表（照着做！） #

🌙 今晚 19:00-21:30（2.5小时）- 第一阶段：高频必刷 #

19:00-19:20（20分钟）- 理论复习 #

先看一遍下面的"5道必背模板"（不要写代码，只看懂）
在纸上默写一遍核心模板框架

19:20-20:00（40分钟）- 栈+括号专题 #

20. 有效的括号（15分钟手写+测试）
- 重点：只压左括号，右括号立即匹配
- 测试："", "(", "()[]{}"
155. 最小栈（10分钟复习）
- 你已经做过，快速过一遍
394. 字符串解码（15分钟复习）
- 你标记需复习，重点看栈存 (num, str) 的逻辑

20:00-20:40（40分钟）- 链表专题 #

206. 反转链表（10分钟复习）
- 你已会，快速默写一遍
141. 环形链表（15分钟）
- 重点：两种方法都要写！
- HashMap法 + 快慢指针法
19. 删除倒数第N个节点（15分钟复习）
- 你已会，快速过一遍

20:40-21:30（50分钟）- DP专题 #

53. 最大子数组和（15分钟手写）
- 简单DP，必须秒杀
198. 打家劫舍（20分钟手写+测试）
- 重点：状态转移方程
- 测试：[], [1], [1,2,3,1]
121. 买卖股票I（15分钟手写）
- 新题，维护最小价格

😴 21:30-22:00（30分钟）- 休息+准备睡觉 #

洗漱、整理明天要带的东西
看一遍下面的"面试话术"（5分钟）

💤 22:00-06:00（8小时）- 睡觉！！！ #

必须睡够！不要熬夜！面试状态比多刷一题重要100倍！

🌅 明早 06:00-08:30（2.5小时）- 第二阶段：补充题型 #

06:00-06:30（30分钟）- 起床+复习昨晚内容 #

起床、洗漱、吃早餐
在纸上默写昨晚做过的题的核心代码（不看答案）
- 有效括号、环形链表、打家劫舍

06:30-07:20（50分钟）- 二叉树专题 #

94. 中序遍历（25分钟）
- 递归法（5分钟）
- 迭代法（20分钟，重点）
144. 先序遍历（25分钟）
- 递归法（5分钟）
- 迭代法（20分钟）

07:20-08:10（50分钟）- 贪心+矩阵专题 #

55. 跳跃游戏（20分钟）
- 贪心算法，维护最远位置
74. 搜索二维矩阵（15分钟）
- 右上角技巧
5. 最长回文子串（15分钟）
- 中心扩展法（如果时间不够可以跳过）

08:10-08:30（20分钟）- 总结 #

在纸上写下所有题目的一句话核心
看一遍边界条件清单

🎯 面试前30分钟（如果面试在下午） #

不要再刷新题！
复习下面的"5道必背模板"
看一遍"边界条件清单"
默念一遍"面试话术"
深呼吸，喝杯水，放松

🔥 5道必背模板（现在就背！） #

1. 有效的括号（20）⭐⭐⭐⭐⭐ #

def isValid(s):
    if not s:
        return True
    stack = []
    mapping = {')':'(', '}':'{', ']':'['}
    
    for char in s:
        if char in mapping:  # 右括号
            if not stack or stack.pop() != mapping[char]:
                return False
        else:  # 左括号
            stack.append(char)
    
    return len(stack) == 0

一句话核心：只压左括号，右括号立即匹配栈顶

2. 环形链表（141）⭐⭐⭐⭐⭐ #

# 方法1: HashMap
def hasCycle(head):
    seen = set()
    while head:
        if head in seen:
            return True
        seen.add(head)
        head = head.next
    return False

# 方法2: 快慢指针（推荐）
def hasCycle(head):
    if not head or not head.next:
        return False
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

一句话核心：快指针走两步，慢指针走一步，相遇就有环

3. 打家劫舍（198）⭐⭐⭐⭐ #

def rob(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    
    prev2 = nums[0]
    prev1 = max(nums[0], nums[1])
    
    for i in range(2, len(nums)):
        curr = max(prev1, prev2 + nums[i])
        prev2 = prev1
        prev1 = curr
    
    return prev1

一句话核心：max(不偷当前, 偷当前+前前个)

4. 最大子数组和（53）⭐⭐⭐⭐ #

def maxSubArray(nums):
    if not nums:
        return 0
    max_sum = curr_sum = nums[0]
    
    for i in range(1, len(nums)):
        curr_sum = max(nums[i], curr_sum + nums[i])
        max_sum = max(max_sum, curr_sum)
    
    return max_sum

一句话核心：当前和 = max(自己, 自己+前面的和)

5. 反转链表（206）⭐⭐⭐⭐⭐ #

def reverseList(head):
    prev = None
    curr = head
    
    while curr:
        next_node = curr.next  # 保存下一个
        curr.next = prev       # 反转指针
        prev = curr            # 移动prev
        curr = next_node       # 移动curr
    
    return prev

一句话核心：三指针 prev, curr, next_node 逐个反转

🧪 边界条件清单（面试必说！） #

遇到任何题，先说这些：

“我需要考虑空输入的情况”
“单元素时需要特殊处理”
“这里可能有负数/重复元素”
“我来测试几个边界…”

具体边界：

数组/字符串：[], [1], [-1], [1,1,1]
链表：None, 1→None, 1→2→None
二叉树：None, 只有根, 只有左/右子树

💬 面试话术（背下来！） #

开场（30秒） #

“让我先理解一下题意…(复述)…输入是XX，输出是XX，对吗？数据范围大概是多少？有特殊情况需要考虑吗？”

说思路（1分钟） #

“我想用XX算法，核心思路是…(简单说)…时间复杂度O(n)，空间O(1)，您看这个方向可以吗？”

写代码中（边写边说） #

“这里我用一个栈来存储…” “这里需要判断边界条件…” “这里是核心逻辑…”

写完代码（主动测试） #

“我来测试几个用例：

空数组返回0

单元素返回它本身

正常情况…(手动走一遍)

看起来没问题！”

面试官追问优化 #

“暴力解法是O(n²)，我可以用XX优化到O(n)，trade-off是空间从O(1)变成O(n)”

🎯 重要提醒（必看3遍！） #

✅ 做到这些，稳了： #

慢慢写，别急：宁可慢一点，不要出低级错误
主动说边界：展示测试思维
变量命名清晰：max_sum 比 m 好
写完就测试：手动走一遍示例

❌ 千万别做： #

❌ 闷头写代码，不说话
❌ 写完不测试，直接说"好了"
❌ 遇到不会的就慌
❌ 熬夜刷题，第二天没精神

💪 最后的话 #

你已经做过20+道题，基础很扎实！

百度测开的题目：

70% 是你做过的（反转链表、两数之和、滑动窗口等）
30% 是简单变形（环形链表两种方法、打家劫舍等）

按照这个计划执行，明天稳了！

现在立即开始第一阶段！不要再看其他资料！就按这个来！

✅ 执行检查清单 #

今晚（19:00-21:30） #

19:00-19:20 看理论
19:20-20:00 栈+括号
20:00-20:40 链表
20:40-21:30 DP
21:30-22:00 休息
22:00 睡觉！

明早（06:00-08:30） #

06:00-06:30 起床+复习
06:30-07:20 二叉树
07:20-08:10 贪心+矩阵
08:10-08:30 总结

面试前30分钟 #

看"5道必背模板"
看"边界条件清单"
默念"面试话术"
深呼吸，放松

✅ 每日检查清单 #

完成今日计划的所有题目
复习昨天的错题（睡前 30 分钟）
整理今日的"一句话灵感"
标记今日遇到的难点