技术面试必备：LeetCode 高频算法题与解题思路总结

2026-05-22 码匠 未分类

无论是校招还是社招，算法面试都是技术面试的重要环节。虽然很多人吐槽「面试造火箭，工作拧螺丝」，但不可否认的是，算法能力确实反映了候选人的基本功和思维素养。本文总结 LeetCode 高频算法题及其解题思路，帮助你更高效地准备技术面试。

一、数组与双指针

1. 两数之和（Two Sum）

最经典的入门题，考察哈希表的使用：

def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        if target - num in seen:
            return [seen[target - num], i]
        seen[num] = i
    return []

核心思想：用空间换时间，一次遍历完成。

2. 三数之和（3Sum）

双指针经典应用：

def threeSum(nums):
    nums.sort()
    res = []
    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i-1]:
            continue  # 去重
        left, right = i + 1, len(nums) - 1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if s < 0: left += 1
            elif s > 0: right -= 1
            else:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1  # 去重
                left += 1
                right -= 1
    return res

3. 盛最多水的容器

双指针从两端向中间收缩：

def maxArea(height):
    left, right = 0, len(height) - 1
    max_area = 0
    while left < right:
        area = min(height[left], height[right]) * (right - left)
        max_area = max(max_area, area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return max_area

二、链表操作

1. 反转链表

经典迭代法：

def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

2. 合并两个有序链表

def mergeTwoLists(l1, l2):
    dummy = ListNode(0)
    curr = dummy
    while l1 and l2:
        if l1.val < l2.val:
            curr.next = l1
            l1 = l1.next
        else:
            curr.next = l2
            l2 = l2.next
        curr = curr.next
    curr.next = l1 or l2
    return dummy.next

3. 环形链表检测

快慢指针：

def hasCycle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

三、二叉树

1. 二叉树遍历

# 前序遍历（递归）
def preorder(root):
    if not root: return []
    return [root.val] + preorder(root.left) + preorder(root.right)

# 层序遍历（BFS）
def levelOrder(root):
    if not root: return []
    res, queue = [], [root]
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.pop(0)
            level.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        res.append(level)
    return res

2. 最大深度

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

四、动态规划

1. 爬楼梯

入门 DP：

def climbStairs(n):
    if n <= 2: return n
    dp = [0] * (n + 1)
    dp[1], dp[2] = 1, 2
    for i in range(3, n + 1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

2. 最长递增子序列（LIS）

def lengthOfLIS(nums):
    dp = [1] * len(nums)
    for i in range(len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

3. 0-1 背包问题

def knapsack(W, wt, val):
    n = len(val)
    dp = [[0] * (W + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        for w in range(1, W + 1):
            if wt[i-1] <= w:
                dp[i][w] = max(dp[i-1][w], dp[i-1][w-wt[i-1]] + val[i-1])
            else:
                dp[i][w] = dp[i-1][w]
    return dp[n][W]

五、滑动窗口

1. 无重复字符的最长子串

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

六、高频题型总结

根据频率排序，以下是面试最常考的题型：

类型高频题目核心技巧
数组两数之和、三数之和、最大子数组和哈希表、双指针、前缀和
链表反转链表、合并链表、环形检测双指针、虚拟头节点
二叉树遍历、最大深度、最近公共祖先递归、BFS/DFS
动态规划爬楼梯、背包问题、最长子序列状态转移方程
字符串最长无重复子串、回文串滑动窗口、中心扩展
图岛屿数量、课程安排BFS/DFS、并查集

七、备考建议

  1. 按类型刷题：先掌握每种类型的模板，再举一反三
  2. 注重思路：面试时思路比代码更重要，先说清楚再写
  3. 多写多练：每道题至少写 3 遍，形成肌肉记忆
  4. 总结模板：每种类型整理自己的模板代码
  5. 模拟面试：找同学或用 LeetCode 面试模式模拟

关于我们

如果你在技术面试准备、项目开发、算法学习等方面需要指导，尊云科技可以为你提供帮助。

我们专注于网站建设、APP开发、小程序开发、PHP/Vue/UniApp开发、API接口、AI集成，拥有丰富的项目经验。

联系方式：

标签：