Table of Contents

测开岗位LeetCode真题汇总 #

本文档整理自2025-2026年各大厂测开岗位真实面经（字节、腾讯、快手、百度、小红书等）数据来源：牛客网、小红书、CSDN等平台真实面经最后更新：2026-02-24

📊 统计概览 #

总题目数：100+（包含LeetCode Hot100 + 剑指Offer高频题）
简单题：25道
中等题：60道
困难题：15道
高频题（出现3次以上）：20道
🆕 补充题（Hot100+剑指Offer）：50道

⭐ 超高频题目（必刷TOP20） #

以下题目在多家公司面试中出现3次以上，务必掌握！

题号	题目	难度	出现公司	频次
1	两数之和	简单	字节、腾讯、百度	5次
206	反转链表	简单	字节、快手、腾讯	6次
20	有效的括号	简单	字节、百度	4次
3	无重复字符的最长子串	中等	字节、小红书、快手	5次
5	最长回文子串	中等	快手、腾讯、百度	4次
121	买卖股票的最佳时机	简单	字节、百度	3次
141	环形链表	简单	字节、腾讯、百度	4次
19	删除链表的倒数第N个节点	中等	快手、字节	3次
704	二分查找	简单	字节、快手、腾讯	4次
53	最大子数组和	中等	字节、百度	3次

📗 简单题（Easy）- 15道 #

🔥 数组类 #

1. 两数之和 #

LeetCode: https://leetcode.cn/problems/two-sum/
出现公司: 字节跳动（一面）、腾讯（二面）、百度（一面）
考察点: 哈希表
解题关键: 用HashMap存储已遍历的数，只需一次遍历
变种: 字节要求只能遍历一次数组，且返回下标从1开始

# 参考解法
def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

704. 二分查找 #

LeetCode: https://leetcode.cn/problems/binary-search/
出现公司: 字节跳动（一面）、快手（一面）、腾讯（二面）
考察点: 二分搜索
解题关键: 注意边界条件，mid的计算避免溢出
变种:
- 字节：给定有序数组和target，找到第一次出现target的位置
- 快手：搜索插入位置

35. 搜索插入位置 #

LeetCode: https://leetcode.cn/problems/search-insert-position/
出现公司: 快手（一面）
考察点: 二分查找
难点: 找不到时返回应该插入的位置

🔥 链表类 #

206. 反转链表 #

LeetCode: https://leetcode.cn/problems/reverse-linked-list/
出现公司: 字节（一面、二面）、快手（一面）、腾讯（一面）
考察点: 链表操作、迭代vs递归
高频程度: ⭐⭐⭐⭐⭐（最高频）
解题关键: 三指针法（prev, curr, next）

# 迭代解法
def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

21. 合并两个有序链表 #

LeetCode: https://leetcode.cn/problems/merge-two-sorted-lists/
出现公司: 字节（一面）
考察点: 链表操作、双指针
解题关键: 使用dummy节点简化代码

141. 环形链表 #

LeetCode: https://leetcode.cn/problems/linked-list-cycle/
出现公司: 字节（二面）、百度（一面）、腾讯（一面）
考察点: 快慢指针
解题关键: Floyd判圈算法

🔥 字符串类 #

20. 有效的括号 #

LeetCode: https://leetcode.cn/problems/valid-parentheses/
出现公司: 字节（一面）、百度（一面）
考察点: 栈
解题关键: 用栈存储左括号，遇到右括号时弹出匹配
测试用例设计: 面试官会让你设计测试用例

125. 验证回文串 #

LeetCode: https://leetcode.cn/problems/valid-palindrome/
出现公司: 腾讯（一面）
考察点: 双指针
解题关键: 只考虑字母和数字，忽略大小写

🔥 其他 #

121. 买卖股票的最佳时机 #

LeetCode: https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/
出现公司: 字节（二面）、百度（一面）
考察点: 动态规划、贪心
解题关键: 记录最小价格，计算最大利润

70. 爬楼梯 #

LeetCode: https://leetcode.cn/problems/climbing-stairs/
出现公司: 快手（一面）
考察点: 动态规划、斐波那契
解题关键: dp[i] = dp[i-1] + dp[i-2]

136. 只出现一次的数字 #

LeetCode: https://leetcode.cn/problems/single-number/
出现公司: 字节（一面）
考察点: 位运算
解题关键: 异或运算（XOR）

283. 移动零 #

LeetCode: https://leetcode.cn/problems/move-zeroes/
来源: LeetCode Hot100
考察点: 双指针
解题关键: 快慢指针，慢指针指向非零元素应该放置的位置

448. 找到所有数组中消失的数字 #

LeetCode: https://leetcode.cn/problems/find-all-numbers-disappeared-in-an-array/
来源: LeetCode Hot100
考察点: 数组、原地修改
解题关键: 将出现过的数字对应位置的数字取反作为标记

169. 多数元素 #

LeetCode: https://leetcode.cn/problems/majority-element/
来源: LeetCode Hot100
考察点: 摩尔投票算法
解题关键: 候选人计数法

🔥 链表类（补充） #

160. 相交链表 #

LeetCode: https://leetcode.cn/problems/intersection-of-two-linked-lists/
来源: LeetCode Hot100 + 剑指Offer 52
考察点: 链表、双指针
解题关键: 两个指针分别遍历两个链表，到达末尾后切换到另一个链表头部

def getIntersectionNode(headA, headB):
    if not headA or not headB:
        return None
    pA, pB = headA, headB
    while pA != pB:
        pA = pA.next if pA else headB
        pB = pB.next if pB else headA
    return pA

234. 回文链表 #

LeetCode: https://leetcode.cn/problems/palindrome-linked-list/
来源: LeetCode Hot100
考察点: 链表、快慢指针
解题关键: 快慢指针找中点，反转后半部分链表，然后比较

🔥 树类（补充） #

104. 二叉树的最大深度 #

LeetCode: https://leetcode.cn/problems/maximum-depth-of-binary-tree/
来源: LeetCode Hot100 + 剑指Offer 55-I
考察点: 二叉树、DFS/BFS
解题关键: 递归或层序遍历

def maxDepth(root):
    if not root:
        return 0
    return max(maxDepth(root.left), maxDepth(root.right)) + 1

101. 对称二叉树 #

LeetCode: https://leetcode.cn/problems/symmetric-tree/
来源: LeetCode Hot100 + 剑指Offer 28
考察点: 二叉树、递归
解题关键: 判断左右子树是否镜像对称

226. 翻转二叉树 #

LeetCode: https://leetcode.cn/problems/invert-binary-tree/
来源: LeetCode Hot100 + 剑指Offer 27
考察点: 二叉树、递归
解题关键: 递归交换左右子树

543. 二叉树的直径 #

LeetCode: https://leetcode.cn/problems/diameter-of-binary-tree/
来源: LeetCode Hot100
考察点: 二叉树、DFS
解题关键: 后序遍历，计算左右子树深度之和

617. 合并二叉树 #

LeetCode: https://leetcode.cn/problems/merge-two-binary-trees/
来源: LeetCode Hot100
考察点: 二叉树、递归
解题关键: 同步遍历两棵树，节点值相加

📘 中等题（Medium）- 30道 #

🔥 数组/字符串类 #

3. 无重复字符的最长子串 #

LeetCode: https://leetcode.cn/problems/longest-substring-without-repeating-characters/
出现公司: 字节（二面）、小红书（二面）、快手（一面）、百度（二面）
考察点: 滑动窗口
高频程度: ⭐⭐⭐⭐⭐
解题关键: 滑动窗口 + HashSet去重
时间复杂度: O(n)

# 滑动窗口解法
def lengthOfLongestSubstring(s):
    char_set = set()
    left = 0
    max_len = 0
    
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)
    
    return max_len

5. 最长回文子串 #

LeetCode: https://leetcode.cn/problems/longest-palindromic-substring/
出现公司: 快手（一面）、腾讯（二面）、百度（一面）
考察点: 动态规划、中心扩展
解题关键:
- 中心扩展法：从每个位置向两边扩展
- 动态规划：dp[i][j]表示s[i:j+1]是否为回文

15. 三数之和 #

LeetCode: https://leetcode.cn/problems/3sum/
出现公司: 字节（二面）
考察点: 双指针、去重
解题关键: 排序后用双指针，注意去重

16. 最接近的三数之和 #

LeetCode: https://leetcode.cn/problems/3sum-closest/
出现公司: 字节（一面）
考察点: 双指针
解题关键: 类似三数之和，记录最接近的和

53. 最大子数组和 #

LeetCode: https://leetcode.cn/problems/maximum-subarray/
出现公司: 字节（一面）、百度（一面）
考察点: 动态规划、贪心
解题关键: Kadane算法

88. 合并两个有序数组 #

LeetCode: https://leetcode.cn/problems/merge-sorted-array/
出现公司: 快手（二面）
考察点: 双指针、原地修改
解题关键: 从后往前填充

11. 盛最多水的容器 #

LeetCode: https://leetcode.cn/problems/container-with-most-water/
来源: LeetCode Hot100
考察点: 双指针、贪心
解题关键: 左右指针向中间移动，每次移动较短的那一边

31. 下一个排列 #

LeetCode: https://leetcode.cn/problems/next-permutation/
来源: LeetCode Hot100 + 剑指Offer II 096
考察点: 数组
解题关键: 从右往左找第一个降序位置，交换后反转

33. 搜索旋转排序数组 #

LeetCode: https://leetcode.cn/problems/search-in-rotated-sorted-array/
来源: LeetCode Hot100
考察点: 二分查找
解题关键: 判断哪一半是有序的，再决定往哪边查找

34. 在排序数组中查找元素的第一个和最后一个位置 #

LeetCode: https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/
来源: LeetCode Hot100 + 剑指Offer 53
考察点: 二分查找
解题关键: 两次二分，分别找左边界和右边界

56. 合并区间 #

LeetCode: https://leetcode.cn/problems/merge-intervals/
来源: LeetCode Hot100
考察点: 数组、排序
解题关键: 先按区间起点排序，然后合并重叠区间

def merge(intervals):
    if not intervals:
        return []
    intervals.sort(key=lambda x: x[0])
    result = [intervals[0]]
    for interval in intervals[1:]:
        if interval[0] <= result[-1][1]:
            result[-1][1] = max(result[-1][1], interval[1])
        else:
            result.append(interval)
    return result

75. 颜色分类 #

LeetCode: https://leetcode.cn/problems/sort-colors/
来源: LeetCode Hot100
考察点: 三指针
解题关键: 荷兰国旗问题，用三个指针分别指向0、1、2的边界

238. 除自身以外数组的乘积 #

LeetCode: https://leetcode.cn/problems/product-of-array-except-self/
来源: LeetCode Hot100 + 剑指Offer 66
考察点: 数组、前缀积
解题关键: 左右两次遍历，分别计算左侧和右侧乘积

287. 寻找重复数 #

LeetCode: https://leetcode.cn/problems/find-the-duplicate-number/
来源: LeetCode Hot100
考察点: 快慢指针、环形链表
解题关键: 将数组看作链表，用Floyd判圈算法

🔥 字符串类（补充） #

49. 字母异位词分组 #

LeetCode: https://leetcode.cn/problems/group-anagrams/
来源: LeetCode Hot100
考察点: 哈希表、字符串
解题关键: 排序后的字符串作为key

def groupAnagrams(strs):
    from collections import defaultdict
    res = defaultdict(list)
    for s in strs:
        key = ''.join(sorted(s))
        res[key].append(s)
    return list(res.values())

394. 字符串解码 #

LeetCode: https://leetcode.cn/problems/decode-string/
来源: LeetCode Hot100
考察点: 栈
解题关键: 用栈存储数字和字符串

647. 回文子串 #

LeetCode: https://leetcode.cn/problems/palindromic-substrings/
来源: LeetCode Hot100
考察点: 动态规划、中心扩展
解题关键: 中心扩展法，每个位置都可能是回文中心

🔥 链表类 #

19. 删除链表的倒数第N个节点 #

LeetCode: https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
出现公司: 字节（一面）、快手（一面）
考察点: 双指针、快慢指针
解题关键: 快指针先走n步，然后同步移动

2. 两数相加 #

LeetCode: https://leetcode.cn/problems/add-two-numbers/
出现公司: 字节（二面）
考察点: 链表操作、进位处理
解题关键: 注意进位和链表长度不同的情况

24. 两两交换链表中的节点 #

LeetCode: https://leetcode.cn/problems/swap-nodes-in-pairs/
出现公司: 腾讯（一面）
考察点: 链表操作
解题关键: 使用dummy节点

148. 排序链表 #

LeetCode: https://leetcode.cn/problems/sort-list/
出现公司: 字节（二面）
考察点: 归并排序、链表操作
解题关键: 自底向上的归并排序

142. 环形链表 II #

LeetCode: https://leetcode.cn/problems/linked-list-cycle-ii/
来源: LeetCode Hot100 + 剑指Offer II 022
考察点: 快慢指针
解题关键: Floyd判圈算法，找到环的入口

25. K 个一组翻转链表（困难，提前到这里） #

LeetCode: https://leetcode.cn/problems/reverse-nodes-in-k-group/
来源: LeetCode Hot100
考察点: 链表、递归
解题关键: 分组反转，每组反转后递归处理下一组

🔥 树类 #

102. 二叉树的层序遍历 #

LeetCode: https://leetcode.cn/problems/binary-tree-level-order-traversal/
出现公司: 字节（一面）、腾讯（一面）
考察点: BFS、队列
解题关键: 用队列实现层序遍历

94. 二叉树的中序遍历 #

LeetCode: https://leetcode.cn/problems/binary-tree-inorder-traversal/
出现公司: 字节（一面）
考察点: DFS、递归vs迭代
解题关键: 迭代需要用栈模拟递归

98. 验证二叉搜索树 #

LeetCode: https://leetcode.cn/problems/validate-binary-search-tree/
出现公司: 腾讯（二面）
考察点: 二叉搜索树性质
解题关键: 中序遍历结果应该是递增的

108. 将有序数组转换为二叉搜索树 #

LeetCode: https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/
出现公司: 小红书（一面）
考察点: 二分、递归
解题关键: 每次选中间元素作为根节点

105. 从前序与中序遍历序列构造二叉树 #

LeetCode: https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
来源: LeetCode Hot100 + 剑指Offer 07
考察点: 二叉树、递归
解题关键: 前序第一个是根，在中序中找到根的位置，递归构建左右子树

114. 二叉树展开为链表 #

LeetCode: https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/
来源: LeetCode Hot100
考察点: 二叉树、前序遍历
解题关键: 右子树接到左子树最右节点，然后左子树接到右边

236. 二叉树的最近公共祖先 #

LeetCode: https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/
来源: LeetCode Hot100 + 剑指Offer 68-II
考察点: 二叉树、DFS
解题关键: 后序遍历，如果当前节点是p或q，返回当前节点

437. 路径总和 III #

LeetCode: https://leetcode.cn/problems/path-sum-iii/
来源: LeetCode Hot100
考察点: 二叉树、前缀和
解题关键: DFS + 前缀和哈希表

538. 把二叉搜索树转换为累加树 #

LeetCode: https://leetcode.cn/problems/convert-bst-to-greater-tree/
来源: LeetCode Hot100 + 剑指Offer II 054
考察点: 二叉搜索树、反向中序遍历
解题关键: 右 → 根 → 左的遍历顺序

🔥 动态规划类 #

198. 打家劫舍 #

LeetCode: https://leetcode.cn/problems/house-robber/
出现公司: 百度（一面）、字节（一面）
考察点: 动态规划
解题关键: dp[i] = max(dp[i-1], dp[i-2] + nums[i])
变种: 百度问了环形打家劫舍（213题）

213. 打家劫舍 II（环形） #

LeetCode: https://leetcode.cn/problems/house-robber-ii/
出现公司: 百度（一面进阶）
考察点: 动态规划
解题关键: 分两种情况（包含第一个或最后一个）

322. 零钱兑换 #

LeetCode: https://leetcode.cn/problems/coin-change/
出现公司: 腾讯（二面）
考察点: 完全背包问题
解题关键: dp[i] = min(dp[i], dp[i-coin] + 1)

1143. 最长公共子序列 #

LeetCode: https://leetcode.cn/problems/longest-common-subsequence/
出现公司: 快手（一面）
考察点: 二维DP
解题关键:
- 如果s1[i] == s2[j]: dp[i][j] = dp[i-1][j-1] + 1
- 否则: dp[i][j] = max(dp[i-1][j], dp[i][j-1])

62. 不同路径 #

LeetCode: https://leetcode.cn/problems/unique-paths/
来源: LeetCode Hot100
考察点: 动态规划
解题关键: dp[i][j] = dp[i-1][j] + dp[i][j-1]

64. 最小路径和 #

LeetCode: https://leetcode.cn/problems/minimum-path-sum/
来源: LeetCode Hot100 + 剑指Offer 47
考察点: 动态规划
解题关键: dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

139. 单词拆分 #

LeetCode: https://leetcode.cn/problems/word-break/
来源: LeetCode Hot100
考察点: 动态规划
解题关键: dp[i]表示s[0:i]能否被拆分，枚举分割点

221. 最大正方形 #

LeetCode: https://leetcode.cn/problems/maximal-square/
来源: LeetCode Hot100
考察点: 动态规划
解题关键: dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1

279. 完全平方数 #

LeetCode: https://leetcode.cn/problems/perfect-squares/
来源: LeetCode Hot100
考察点: 动态规划、BFS
解题关键: 完全背包问题

300. 最长递增子序列 #

LeetCode: https://leetcode.cn/problems/longest-increasing-subsequence/
来源: LeetCode Hot100 + 剑指Offer II 091
考察点: 动态规划、二分查找
解题关键:
- 方法1：DP，dp[i]表示以nums[i]结尾的最长递增子序列长度
- 方法2：贪心+二分，维护一个递增序列

# 方法1：DP，O(n²)
def lengthOfLIS(nums):
    if not nums:
        return 0
    dp = [1] * len(nums)
    for i in range(len(nums)):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

# 方法2：贪心+二分，O(nlogn)
def lengthOfLIS(nums):
    tails = []
    for num in nums:
        left, right = 0, len(tails)
        while left < right:
            mid = (left + right) // 2
            if tails[mid] < num:
                left = mid + 1
            else:
                right = mid
        if right >= len(tails):
            tails.append(num)
        else:
            tails[right] = num
    return len(tails)

309. 最佳买卖股票时机含冷冻期 #

LeetCode: https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/
来源: LeetCode Hot100
考察点: 动态规划、状态机
解题关键: 三个状态：持有、不持有（可买入）、冷冻期

337. 打家劫舍 III #

LeetCode: https://leetcode.cn/problems/house-robber-iii/
来源: LeetCode Hot100
考察点: 树形DP
解题关键: 后序遍历，返回两个值（偷/不偷当前节点）

416. 分割等和子集 #

LeetCode: https://leetcode.cn/problems/partition-equal-subset-sum/
来源: LeetCode Hot100
考察点: 0-1背包问题
解题关键: 转化为背包容量为sum/2的0-1背包问题

494. 目标和 #

LeetCode: https://leetcode.cn/problems/target-sum/
来源: LeetCode Hot100 + 剑指Offer II 102
考察点: 动态规划、0-1背包
解题关键: 转化为找子集和等于(target + sum) / 2

🔥 栈/队列类 #

155. 最小栈 #

LeetCode: https://leetcode.cn/problems/min-stack/
出现公司: 字节（一面）
考察点: 栈、设计数据结构
解题关键: 用辅助栈存储最小值

232. 用栈实现队列 #

LeetCode: https://leetcode.cn/problems/implement-queue-using-stacks/
出现公司: 腾讯（一面）
考察点: 栈、队列
解题关键: 用两个栈，一个输入栈，一个输出栈

739. 每日温度 #

LeetCode: https://leetcode.cn/problems/daily-temperatures/
来源: LeetCode Hot100
考察点: 单调栈
解题关键: 维护一个单调递减的栈，存储下标

def dailyTemperatures(temperatures):
    n = len(temperatures)
    ans = [0] * n
    stack = []
    for i in range(n):
        while stack and temperatures[i] > temperatures[stack[-1]]:
            prev = stack.pop()
            ans[prev] = i - prev
        stack.append(i)
    return ans

394. 字符串解码（移到这里更合适） #

LeetCode: https://leetcode.cn/problems/decode-string/
来源: LeetCode Hot100
考察点: 栈
解题关键: 用栈存储数字和字符串

🔥 回溯类（新增） #

17. 电话号码的字母组合 #

LeetCode: https://leetcode.cn/problems/letter-combinations-of-a-phone-number/
来源: LeetCode Hot100
考察点: 回溯
解题关键: DFS遍历所有可能的组合

22. 括号生成 #

LeetCode: https://leetcode.cn/problems/generate-parentheses/
来源: LeetCode Hot100
考察点: 回溯
解题关键: 左括号数量 < n 可以加左括号，右括号数量 < 左括号数量可以加右括号

def generateParenthesis(n):
    res = []
    def backtrack(s, left, right):
        if len(s) == 2 * n:
            res.append(s)
            return
        if left < n:
            backtrack(s + '(', left + 1, right)
        if right < left:
            backtrack(s + ')', left, right + 1)
    backtrack('', 0, 0)
    return res

39. 组合总和 #

LeetCode: https://leetcode.cn/problems/combination-sum/
来源: LeetCode Hot100
考察点: 回溯
解题关键: 可以重复选择同一个数，用start控制不重复

46. 全排列 #

LeetCode: https://leetcode.cn/problems/permutations/
来源: LeetCode Hot100 + 剑指Offer 38
考察点: 回溯
解题关键: 用used数组标记已使用的元素

def permute(nums):
    res = []
    def backtrack(path, used):
        if len(path) == len(nums):
            res.append(path[:])
            return
        for i in range(len(nums)):
            if used[i]:
                continue
            path.append(nums[i])
            used[i] = True
            backtrack(path, used)
            path.pop()
            used[i] = False
    backtrack([], [False] * len(nums))
    return res

78. 子集 #

LeetCode: https://leetcode.cn/problems/subsets/
来源: LeetCode Hot100 + 剑指Offer II 079
考察点: 回溯
解题关键: 每个元素都有选或不选两种情况

79. 单词搜索 #

LeetCode: https://leetcode.cn/problems/word-search/
来源: LeetCode Hot100 + 剑指Offer 12
考察点: 回溯、DFS
解题关键: 标记访问过的位置，四个方向DFS

🔥 图/BFS/DFS类（新增） #

200. 岛屿数量 #

LeetCode: https://leetcode.cn/problems/number-of-islands/
来源: LeetCode Hot100
考察点: DFS/BFS、并查集
解题关键: 遍历每个格子，遇到'1’就DFS/BFS感染所有连通的'1'

def numIslands(grid):
    if not grid:
        return 0
    count = 0
    def dfs(i, j):
        if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] != '1':
            return
        grid[i][j] = '0'
        dfs(i+1, j)
        dfs(i-1, j)
        dfs(i, j+1)
        dfs(i, j-1)
    
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                count += 1
                dfs(i, j)
    return count

207. 课程表 #

LeetCode: https://leetcode.cn/problems/course-schedule/
来源: LeetCode Hot100
考察点: 拓扑排序、DFS/BFS
解题关键: 检测有向图中是否有环

🔥 哈希表类 #

560. 和为K的子数组 #

LeetCode: https://leetcode.cn/problems/subarray-sum-equals-k/
出现公司: 小红书（三面）
考察点: 前缀和、哈希表
解题关键: 用哈希表存储前缀和出现次数

128. 最长连续序列 #

LeetCode: https://leetcode.cn/problems/longest-consecutive-sequence/
来源: LeetCode Hot100
考察点: 哈希表
解题关键: 用HashSet，只从连续序列的起点开始计数

347. 前 K 个高频元素 #

LeetCode: https://leetcode.cn/problems/top-k-frequent-elements/
来源: LeetCode Hot100 + 剑指Offer II 060
考察点: 哈希表、堆、桶排序
解题关键: 用HashMap统计频次，然后用最小堆或桶排序

438. 找到字符串中所有字母异位词 #

LeetCode: https://leetcode.cn/problems/find-all-anagrams-in-a-string/
来源: LeetCode Hot100 + 剑指Offer II 015
考察点: 滑动窗口、哈希表
解题关键: 固定窗口大小的滑动窗口

🔥 堆/优先队列类（新增） #

215. 数组中的第K个最大元素 #

LeetCode: https://leetcode.cn/problems/kth-largest-element-in-an-array/
来源: LeetCode Hot100 + 剑指Offer II 076
考察点: 快速选择、堆
解题关键:
- 方法1：最小堆，维护大小为k的堆
- 方法2：快速选择算法

# 最小堆方法
import heapq
def findKthLargest(nums, k):
    heap = []
    for num in nums:
        if len(heap) < k:
            heapq.heappush(heap, num)
        elif num > heap[0]:
            heapq.heapreplace(heap, num)
    return heap[0]

🔥 其他高频题 #

54. 螺旋矩阵 #

LeetCode: https://leetcode.cn/problems/spiral-matrix/
出现公司: 快手（一面）
考察点: 矩阵遍历、模拟
解题关键: 控制四个边界

74. 搜索二维矩阵 #

LeetCode: https://leetcode.cn/problems/search-a-2d-matrix/
出现公司: 百度（三面）
考察点: 二分查找
解题关键: 把二维矩阵看作一维数组

48. 旋转图像 #

LeetCode: https://leetcode.cn/problems/rotate-image/
出现公司: 字节（二面）
考察点: 矩阵操作
解题关键: 先转置，再翻转每一行

📕 困难题（Hard）- 5道 #

23. 合并K个升序链表 #

LeetCode: https://leetcode.cn/problems/merge-k-sorted-lists/
出现公司: 腾讯（一面）、字节（二面）
考察点: 堆、分治
解题关键:
- 方法1：最小堆
- 方法2：分治合并

42. 接雨水 #

LeetCode: https://leetcode.cn/problems/trapping-rain-water/
出现公司: 字节（三面）
考察点: 双指针、单调栈
解题关键: 双指针法，左右各一个指针

32. 最长有效括号 #

LeetCode: https://leetcode.cn/problems/longest-valid-parentheses/
出现公司: 字节（二面）
考察点: 栈、动态规划
解题关键: 用栈存储索引

115. 不同的子序列 #

LeetCode: https://leetcode.cn/problems/distinct-subsequences/
出现公司: 小红书（二面，算法题2）
考察点: 动态规划
解题关键: 二维DP，考虑匹配和不匹配两种情况

295. 数据流的中位数 #

LeetCode: https://leetcode.cn/problems/find-median-from-data-stream/
出现公司: 字节（三面）
考察点: 堆、设计数据结构
解题关键: 用两个堆（大顶堆+小顶堆）

4. 寻找两个正序数组的中位数 #

LeetCode: https://leetcode.cn/problems/median-of-two-sorted-arrays/
来源: LeetCode Hot100 + 剑指Offer II 078
考察点: 二分查找
解题关键: 在较短的数组上进行二分，找到合适的划分位置

72. 编辑距离 #

LeetCode: https://leetcode.cn/problems/edit-distance/
来源: LeetCode Hot100
考察点: 动态规划
解题关键: dp[i][j]表示word1[0:i]转换为word2[0:j]的最小操作数

def minDistance(word1, word2):
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
    
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = min(
                    dp[i-1][j] + 1,    # 删除
                    dp[i][j-1] + 1,    # 插入
                    dp[i-1][j-1] + 1   # 替换
                )
    return dp[m][n]

76. 最小覆盖子串 #

LeetCode: https://leetcode.cn/problems/minimum-window-substring/
来源: LeetCode Hot100 + 剑指Offer II 017
考察点: 滑动窗口、哈希表
解题关键: 右指针扩展窗口，左指针收缩窗口

84. 柱状图中最大的矩形 #

LeetCode: https://leetcode.cn/problems/largest-rectangle-in-histogram/
来源: LeetCode Hot100
考察点: 单调栈
解题关键: 维护单调递增栈，遇到更小的高度时计算面积

def largestRectangleArea(heights):
    stack = []
    max_area = 0
    heights.append(0)  # 哨兵
    
    for i, h in enumerate(heights):
        while stack and h < heights[stack[-1]]:
            height = heights[stack.pop()]
            width = i if not stack else i - stack[-1] - 1
            max_area = max(max_area, height * width)
        stack.append(i)
    
    return max_area

85. 最大矩形 #

LeetCode: https://leetcode.cn/problems/maximal-rectangle/
来源: LeetCode Hot100
考察点: 单调栈、动态规划
解题关键: 转化为84题，每一行看作柱状图的底

124. 二叉树中的最大路径和 #

LeetCode: https://leetcode.cn/problems/binary-tree-maximum-path-sum/
来源: LeetCode Hot100 + 剑指Offer II 051
考察点: 二叉树、DFS
解题关键: 后序遍历，每个节点可以选择左右子树的最大贡献

146. LRU 缓存 #

LeetCode: https://leetcode.cn/problems/lru-cache/
来源: LeetCode Hot100 + 剑指Offer II 031
考察点: 设计数据结构、哈希表+双向链表
解题关键: 哈希表存储key到节点的映射，双向链表维护访问顺序

class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.capacity = capacity
        self.size = 0
    
    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.moveToHead(node)
        return node.value
    
    def put(self, key: int, value: int) -> None:
        if key not in self.cache:
            node = DLinkedNode(key, value)
            self.cache[key] = node
            self.addToHead(node)
            self.size += 1
            if self.size > self.capacity:
                removed = self.removeTail()
                self.cache.pop(removed.key)
                self.size -= 1
        else:
            node = self.cache[key]
            node.value = value
            self.moveToHead(node)
    
    def addToHead(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    
    def removeNode(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev
    
    def moveToHead(self, node):
        self.removeNode(node)
        self.addToHead(node)
    
    def removeTail(self):
        node = self.tail.prev
        self.removeNode(node)
        return node

208. 实现 Trie (前缀树) #

LeetCode: https://leetcode.cn/problems/implement-trie-prefix-tree/
来源: LeetCode Hot100 + 剑指Offer II 062
考察点: 设计数据结构、字典树
解题关键: 用字典树存储单词，每个节点包含26个子节点

239. 滑动窗口最大值 #

LeetCode: https://leetcode.cn/problems/sliding-window-maximum/
来源: LeetCode Hot100 + 剑指Offer 59-I
考察点: 单调队列
解题关键: 维护单调递减的双端队列，存储下标

301. 删除无效的括号 #

LeetCode: https://leetcode.cn/problems/remove-invalid-parentheses/
来源: LeetCode Hot100
考察点: BFS、回溯
解题关键: BFS层序遍历，每层删除一个字符

312. 戳气球 #

LeetCode: https://leetcode.cn/problems/burst-balloons/
来源: LeetCode Hot100
考察点: 区间DP
解题关键: dp[i][j]表示戳破(i,j)之间所有气球的最大收益

🎯 剑指Offer特有高频题（新增） #

以下是剑指Offer中特别经典，但LeetCode Hot100中没有的题目：

剑指Offer 03. 数组中重复的数字 #

LeetCode: https://leetcode.cn/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/
考察点: 数组、原地修改
解题关键: 将每个数放到对应下标位置，出现冲突即为重复

剑指Offer 04. 二维数组中的查找 #

LeetCode: https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/
对应: LeetCode 240
考察点: 二分查找
解题关键: 从右上角或左下角开始搜索

剑指Offer 05. 替换空格 #

LeetCode: https://leetcode.cn/problems/ti-huan-kong-ge-lcof/
考察点: 字符串
解题关键: 从后往前替换，或者直接用replace

剑指Offer 06. 从尾到头打印链表 #

LeetCode: https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/
考察点: 链表、栈、递归
解题关键: 用栈存储或递归

剑指Offer 09. 用两个栈实现队列 #

LeetCode: https://leetcode.cn/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/
对应: LeetCode 232
考察点: 栈、队列
解题关键: 一个输入栈，一个输出栈

剑指Offer 10-I. 斐波那契数列 #

LeetCode: https://leetcode.cn/problems/fei-bo-na-qi-shu-lie-lcof/
对应: LeetCode 509
考察点: 动态规划
解题关键: dp[i] = dp[i-1] + dp[i-2]，注意取模

剑指Offer 10-II. 青蛙跳台阶问题 #

LeetCode: https://leetcode.cn/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/
对应: LeetCode 70
考察点: 动态规划
解题关键: 和斐波那契数列相同

剑指Offer 11. 旋转数组的最小数字 #

LeetCode: https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/
对应: LeetCode 154
考察点: 二分查找
解题关键: 和右边界比较，缩小范围

剑指Offer 12. 矩阵中的路径 #

LeetCode: https://leetcode.cn/problems/ju-zhen-zhong-de-lu-jing-lcof/
对应: LeetCode 79
考察点: 回溯、DFS
解题关键: 四个方向DFS，标记访问过的位置

剑指Offer 15. 二进制中1的个数 #

LeetCode: https://leetcode.cn/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/
对应: LeetCode 191
考察点: 位运算
解题关键: n & (n-1) 可以消除最右边的1

剑指Offer 22. 链表中倒数第k个节点 #

LeetCode: https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/
考察点: 链表、快慢指针
解题关键: 快指针先走k步

💡 刷题建议 #

优先级排序 #

第一阶段（基础）：简单题全部刷完（15道）
第二阶段（进阶）：中等题的高频题（标记⭐⭐⭐⭐⭐的）
第三阶段（拔高）：剩余中等题 + 困难题

按公司准备 #

字节跳动：重点刷链表、数组、字符串（高频：3、5、206、19、141）
腾讯：重点刷树、动态规划（高频：102、198、322）
快手：重点刷数组、矩阵、字符串（高频：3、5、54）
百度：重点刷动态规划、数组（高频：198、213、53）
小红书：重点刷字符串、哈希表、DP（高频：3、560、115）

时间分配建议 #

简单题：10-15分钟/题
中等题：20-30分钟/题
困难题：30-45分钟/题

面试技巧 #

先说思路：不要一上来就写代码，先跟面试官确认思路
考虑边界：主动提出边界情况和测试用例
优化空间：如果有更优解，主动提出并讨论
代码规范：变量命名清晰，适当添加注释
测试用例：写完代码后主动设计测试用例验证

📚 相关资源 #

LeetCode中国站: https://leetcode.cn/
牛客网: https://www.nowcoder.com/
代码随想录: https://programmercarl.com/
labuladong算法小抄: https://labuladong.github.io/algo/

📝 更新日志 #

2026-02-24 v1.0：初版发布，包含50+道真题（来自各大厂真实面经）
2026-02-24 v2.0：补充LeetCode Hot100 + 剑指Offer高频题，新增50+道题目
- 新增简单题10道
- 新增中等题30道
- 新增困难题10道
- 新增剑指Offer特有题10道
- 总题目数达到100+

🎯 题目覆盖度分析 #

LeetCode Hot100 覆盖情况 #

✅ 数组/字符串：90%覆盖
✅ 链表：95%覆盖
✅ 树：85%覆盖
✅ 动态规划：90%覆盖
✅ 回溯：80%覆盖
✅ 栈/队列：90%覆盖
✅ 图/BFS/DFS：70%覆盖
✅ 堆：85%覆盖

剑指Offer 覆盖情况 #

✅ 高频题：80%覆盖
✅ 经典题：70%覆盖

祝你刷题顺利，面试成功！ 🎉