大厂高频算法题精讲（如二叉树遍历、动态规划背包问题）

引言：为什么算法题是大厂面试的核心？

在大厂技术面试中，算法题是考察候选人逻辑思维、编码能力和问题解决能力的核心环节。高频算法题如二叉树遍历、动态规划背包问题等，往往因其既能考察基础数据结构知识，又能体现对复杂问题的拆解能力，成为面试中的“常客”。本文将从代码实现、解题思路到优化技巧，系统剖析这些高频算法题，助你高效备战大厂面试！

一、二叉树遍历：从递归到非递归的全面掌握

二叉树是数据结构中的基础，其遍历方式更是常考题型。常见的遍历方式包括前序、中序、后序（递归与非递归）以及层次遍历。

1. 递归遍历：简洁但需警惕栈溢出

# 前序遍历（根-左-右）
def preorder(root):
    if not root:
        return
    print(root.val)
    preorder(root.left)
    preorder(root.right)

# 中序遍历（左-根-右）
def inorder(root):
    if not root:
        return
    inorder(root.left)
    print(root.val)
    inorder(root.right)

# 后序遍历（左-右-根）
def postorder(root):
    if not root:
        return
    postorder(root.left)
    postorder(root.right)
    print(root.val)

2. 非递归遍历：面试官更青睐的写法

核心思路：用栈模拟递归过程。

# 前序遍历（非递归）
def preorder_stack(root):
    stack, res = [root], []
    while stack:
        node = stack.pop()
        if node:
            res.append(node.val)
            stack.append(node.right)  # 右子节点先入栈，后出栈
            stack.append(node.left)
    return res

# 中序遍历（非递归）
def inorder_stack(root):
    stack, res = [], []
    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

3. 层次遍历：BFS的典型应用

from collections import deque

def level_order(root):
    if not root:
        return []
    q = deque([root])
    res = []
    while q:
        level_size = len(q)
        level = []
        for _ in range(level_size):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        res.append(level)
    return res

4. 高频变种题

剑指 Offer 32 - III. 之字形打印二叉树：在层次遍历基础上，交替反转每层结果。
LeetCode 105. 从前序与中序遍历序列构造二叉树：利用递归分治思想，定位根节点位置。

二、动态规划背包问题：从01背包到完全背包

背包问题是动态规划（DP）中的经典模型，重点考察状态转移方程设计和空间优化技巧。

1. 01背包问题：每个物品最多选一次

问题描述：给定物品重量weights、价值values和背包容量capacity，求能装的最大价值。

（1）标准解法：二维DP数组

def knapsack_01(weights, values, capacity):
    n = len(weights)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
  
    for i in range(1, n + 1):
        for w in range(1, capacity + 1):
            if weights[i-1] > w:
                dp[i][w] = dp[i-1][w]
            else:
                dp[i][w] = max(dp[i-1][w], dp[i-1][w - weights[i-1]] + values[i-1])
    return dp[n][capacity]

（2）空间优化：一维滚动数组

def knapsack_01_optimized(weights, values, capacity):
    n = len(weights)
    dp = [0] * (capacity + 1)
  
    for i in range(n):
        for w in range(capacity, weights[i]-1, -1):  # 逆序遍历避免重复计算
            dp[w] = max(dp[w], dp[w - weights[i]] + values[i])
    return dp[capacity]

2. 完全背包问题：物品无限次选择

与01背包的区别仅在于遍历顺序（正序遍历）：

def complete_knapsack(weights, values, capacity):
    dp = [0] * (capacity + 1)
    for i in range(n):
        for w in range(weights[i], capacity + 1):  # 正序遍历
            dp[w] = max(dp[w], dp[w - weights[i]] + values[i])
    return dp[capacity]