力扣二叉树刷题指南：从基础到实战技巧

1. 二叉树基础回顾与力扣刷题策略

在开始第二集的力扣二叉树简单题整理之前，我们先快速回顾一下二叉树的基础知识。二叉树是每个节点最多有两个子节点的树结构，通常称为左子树和右子树。力扣(LeetCode)上的二叉树题目主要考察以下几个核心概念：

• 二叉树的遍历方式（前序、中序、后序、层序）
• 递归与迭代的实现差异
• 二叉树的基本性质（深度、节点数、对称性等）
• 特殊二叉树结构（二叉搜索树、平衡二叉树等）

我在力扣刷题过程中发现，很多看似简单的二叉树题目其实暗藏玄机。比如一道标为"简单"的对称二叉树问题，如果对递归理解不够深入，很容易写出错误的解法。因此我建议即使是简单题也要认真对待，每道题至少尝试两种解法。

提示：力扣的题目难度评级有时会误导人，建议根据自身情况调整刷题顺序，不必严格按简单→中等→困难的顺序进行。

2. 精选题目解析：路径总和问题

2.1 题目112：路径总和

题目描述：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，使得路径上所有节点值相加等于目标和。

这道题看似简单，但有几个关键点需要注意：

1. 必须是根到叶子节点的完整路径
2. 节点值可能为负数
3. 空树情况需要特殊处理

递归解法代码实现：

python复制def hasPathSum(root, targetSum):
    if not root:
        return False
    if not root.left and not root.right:
        return targetSum == root.val
    return hasPathSum(root.left, targetSum - root.val) or hasPathSum(root.right, targetSum - root.val)

这个解法的时间复杂度是O(n)，空间复杂度在最坏情况下（树退化为链表）也是O(n)。

迭代解法使用栈：

python复制def hasPathSum(root, targetSum):
    if not root:
        return False
    stack = [(root, targetSum - root.val)]
    while stack:
        node, curr_sum = stack.pop()
        if not node.left and not node.right and curr_sum == 0:
            return True
        if node.right:
            stack.append((node.right, curr_sum - node.right.val))
        if node.left:
            stack.append((node.left, curr_sum - node.left.val))
    return False

2.2 常见错误与调试技巧

在实际编码中，我发现新手容易犯以下几个错误：

1. 忘记处理空树情况
2. 没有严格判断叶子节点（误把非叶子节点当作终止条件）
3. 在迭代解法中弄错栈的压入顺序（应该先右后左）

调试时可以添加打印语句输出当前路径和剩余目标值，例如：

python复制print(f"当前节点值：{node.val}，剩余目标值：{curr_sum}")

3. 二叉树的最小深度问题

3.1 题目111：二叉树的最小深度

题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

这道题与求最大深度不同，有一个关键陷阱：当某节点只有左子树或右子树时，不能直接取较小值。

正确解法：

python复制def minDepth(root):
    if not root:
        return 0
    if not root.left:
        return minDepth(root.right) + 1
    if not root.right:
        return minDepth(root.left) + 1
    return min(minDepth(root.left), minDepth(root.right)) + 1

层序遍历解法（BFS）：

python复制from collections import deque

def minDepth(root):
    if not root:
        return 0
    queue = deque([(root, 1)])
    while queue:
        node, depth = queue.popleft()
        if not node.left and not node.right:
            return depth
        if node.left:
            queue.append((node.left, depth + 1))
        if node.right:
            queue.append((node.right, depth + 1))
    return 0

BFS解法在找到第一个叶子节点时即可返回，通常效率更高。

3.2 性能对比与选择建议

我测试了两种解法在不同规模二叉树上的表现：

从测试结果可以看出：

1. 对于平衡树，两种解法差异不大
2. 对于偏斜树，BFS优势明显
3. 随着树规模增大，BFS的相对优势更明显

因此我建议在实际面试中，可以先给出递归解法，然后主动提出可以优化为BFS解法。

4. 平衡二叉树判断问题

4.1 题目110：平衡二叉树

题目描述：给定一个二叉树，判断它是否是高度平衡的二叉树。高度平衡二叉树定义为：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。

这道题的关键在于如何高效计算子树高度并比较。

自顶向下解法：

python复制def isBalanced(root):
    def height(node):
        if not node:
            return 0
        return max(height(node.left), height(node.right)) + 1
    
    if not root:
        return True
    return abs(height(root.left) - height(root.right)) <= 1 and \
           isBalanced(root.left) and isBalanced(root.right)

这个解法的时间复杂度是O(nlogn)，因为每个节点的高度会被重复计算多次。

自底向上优化解法：

python复制def isBalanced(root):
    def check(node):
        if not node:
            return 0
        left = check(node.left)
        right = check(node.right)
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        return max(left, right) + 1
    
    return check(root) != -1

优化后的解法时间复杂度降为O(n)，因为每个节点的高度只计算一次。

4.2 实际应用中的注意事项

在真实项目中使用平衡二叉树判断时，有几个实用技巧：

1. 可以添加缓存装饰器存储已计算的子树高度
2. 对于大规模数据，自底向上解法是必须的
3. 调试时可以打印每个节点的平衡状态：

python复制print(f"节点{node.val}：左高={left}，右高={right}，平衡={abs(left-right)<=1}")

5. 二叉树的所有路径问题

5.1 题目257：二叉树的所有路径

题目描述：给定一个二叉树，返回所有从根节点到叶子节点的路径。

这道题考察的是如何记录遍历路径，需要注意字符串拼接的效率问题。

递归解法：

python复制def binaryTreePaths(root):
    def construct_paths(node, path):
        if node:
            path += str(node.val)
            if not node.left and not node.right:
                paths.append(path)
            else:
                path += "->"
                construct_paths(node.left, path)
                construct_paths(node.right, path)
    
    paths = []
    construct_paths(root, "")
    return paths

迭代解法：

python复制def binaryTreePaths(root):
    if not root:
        return []
    paths = []
    stack = [(root, str(root.val))]
    while stack:
        node, path = stack.pop()
        if not node.left and not node.right:
            paths.append(path)
        if node.left:
            stack.append((node.left, path + "->" + str(node.left.val)))
        if node.right:
            stack.append((node.right, path + "->" + str(node.right.val)))
    return paths

5.3 字符串处理优化技巧

在处理路径字符串时，有几种优化方法：

1. 使用列表存储路径节点，最后用join拼接（减少字符串拼接开销）
2. 对于大型树，使用yield生成路径（节省内存）
3. 使用StringIO对象进行高效字符串构建

优化后的实现：

python复制from io import StringIO

def binaryTreePaths(root):
    def traverse(node, path, res):
        if not node:
            return
        path.write(str(node.val))
        if not node.left and not node.right:
            res.append(path.getvalue())
        else:
            path.write("->")
            left_path = StringIO(path.getvalue())
            right_path = StringIO(path.getvalue())
            traverse(node.left, left_path, res)
            traverse(node.right, right_path, res)
    
    res = []
    traverse(root, StringIO(), res)
    return res

6. 左叶子之和问题

6.1 题目404：左叶子之和

题目描述：计算给定二叉树的所有左叶子之和。

这道题的关键在于准确识别什么是左叶子节点。

递归解法：

python复制def sumOfLeftLeaves(root):
    def helper(node, is_left):
        if not node:
            return 0
        if not node.left and not node.right:
            return node.val if is_left else 0
        return helper(node.left, True) + helper(node.right, False)
    
    return helper(root, False)

迭代解法：

python复制def sumOfLeftLeaves(root):
    if not root:
        return 0
    stack = [(root, False)]
    total = 0
    while stack:
        node, is_left = stack.pop()
        if not node.left and not node.right and is_left:
            total += node.val
        if node.right:
            stack.append((node.right, False))
        if node.left:
            stack.append((node.left, True))
    return total

6.2 边界情况处理

在实际测试中，我发现以下几种边界情况需要特别注意：

1. 只有右子树的树应该返回0
2. 单节点树应该返回0（因为不是左叶子）
3. 所有左节点都是非叶子节点的情况
4. 节点值为负数的情况

测试用例示例：

python复制# 只有右子树
tree1 = TreeNode(1, None, TreeNode(2))
assert sumOfLeftLeaves(tree1) == 0

# 单节点树
tree2 = TreeNode(1)
assert sumOfLeftLeaves(tree2) == 0

# 混合情况
tree3 = TreeNode(3, TreeNode(9), TreeNode(20, TreeNode(15), TreeNode(7)))
assert sumOfLeftLeaves(tree3) == 24  # 9 + 15

7. 力扣刷题的系统性方法

经过这些二叉树简单题的训练，我总结出一套系统的刷题方法：

1. 题目分类：将二叉树题目按类型分类（遍历、属性判断、构造等）
2. 模板整理：为每类题目整理代码模板
3. 多解法实现：每道题至少用两种方法实现
4. 复杂度分析：明确写出每种解法的时间空间复杂度
5. 测试用例设计：包括常规情况和各种边界情况

以二叉树遍历为例，我的代码模板如下：

python复制# 递归前序遍历模板
def preorder(root):
    if not root:
        return
    # 处理当前节点
    print(root.val)
    preorder(root.left)
    preorder(root.right)

# 迭代前序遍历模板
def preorder(root):
    if not root:
        return
    stack = [root]
    while stack:
        node = stack.pop()
        print(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)

对于刷题顺序，我建议按照以下顺序进行：

1. 基础遍历题（前中后序）
2. 属性判断题（对称、平衡等）
3. 路径相关问题
4. 构造类问题
5. 二叉搜索树专题

在实际面试中，二叉树题目经常被用作考察候选人的基本功。我发现面试官最看重的几点是：

1. 能否准确理解题意
2. 能否考虑到各种边界情况
3. 代码是否简洁高效
4. 能否分析算法复杂度
5. 能否进行优化

最后分享一个实用技巧：在力扣上刷题时，可以先用简单题熟悉基本模式，然后用相同模式的中等题巩固，最后用难题挑战自己。比如先做"二叉树的最大深度"(104)，然后尝试"二叉树的最小深度"(111)，最后挑战"二叉树的直径"(543)。这种渐进式的学习方法效果非常好。