二叉树核心算法：遍历、深度计算与构造解析-代码聚汇网

二叉树核心算法：遍历、深度计算与构造解析

布局图·2026-08-07·阅读 22 GEO检测（免费）

二叉树遍历算法最小深度

|难度：普通|阅读约 19 分钟

1. 二叉树基础与核心算法解析

二叉树作为数据结构中最基础也最重要的非线性结构之一，在算法面试和实际工程中都有着广泛应用。不同于线性表的一维结构，二叉树的二维特性使得其遍历和操作需要特殊的处理方式。本文将深入解析五个经典二叉树问题，从基础概念到优化解法，帮助读者系统掌握二叉树算法的核心思路。

1.1 二叉树的基本特性与遍历方式

二叉树每个节点最多有两个子节点，分别称为左子节点和右子节点。根据节点排列方式的不同，二叉树可以分为：

满二叉树：所有非叶子节点都有两个子节点，且所有叶子节点都在同一层
完全二叉树：除最后一层外，其他层节点数都达到最大值，最后一层节点都集中在左侧
二叉搜索树：左子树所有节点值小于根节点，右子树所有节点值大于根节点

二叉树的遍历主要有四种方式：

前序遍历：根节点 -> 左子树 -> 右子树
中序遍历：左子树 -> 根节点 -> 右子树
后序遍历：左子树 -> 右子树 -> 根节点
层序遍历：按层次从上到下、从左到右访问节点

提示：不同的遍历方式适用于不同场景。前序适合复制树结构，中序适合二叉搜索树排序，后序适合删除树节点，层序适合计算树的高度或宽度。

1.2 算法问题分类与解题思路

本文将详细解析的五个二叉树问题可以分为三类：

基本属性计算：最小深度、节点个数
平衡性判断：平衡二叉树
路径与构造：路径总和、从中序与后序构造二叉树

解决二叉树问题的通用思路包括：

递归法：利用树的自相似性，定义递归函数处理当前节点及其子树
迭代法：使用栈或队列模拟递归过程，避免递归带来的栈溢出风险
分治法：将问题分解为子问题，合并子问题的解得到最终结果

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 二叉树的最小深度计算

2.1 问题定义与边界条件

二叉树的最小深度是指从根节点到最近叶子节点的最短路径上的节点数量。需要注意的是：

叶子节点是指没有子节点的节点
对于空树，最小深度为0
对于只有根节点的树，最小深度为1

常见误区是将最小深度简单等同于树的高度或直接使用最大深度的计算方法，这会导致错误结果。例如对于单边倾斜的树（所有节点只有左子节点或只有右子节点），最小深度应该沿着有子节点的方向计算。

2.2 递归解法实现

递归解法需要考虑三种基本情况：

当前节点为空：返回0
当前节点无子节点：返回1
当前节点有子节点：分别计算左右子树的最小深度，取较小值加1

python复制def minDepth(root):
    if not root:
        return 0
    if not root.left and not root.right:
        return 1
    left_depth = minDepth(root.left) if root.left else float('inf')
    right_depth = minDepth(root.right) if root.right else float('inf')
    return min(left_depth, right_depth) + 1

注意：当某子树为空时，不能直接取其最小深度为0，而应视为无穷大，否则会错误地将当前节点判断为叶子节点。

2.3 迭代解法优化

使用广度优先搜索（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

这种方法的时间复杂度在最坏情况下为O(n)，空间复杂度为O(w)，其中w是树的最大宽度。相比递归的DFS方法，BFS在找到最小深度时通常更高效。

3. 完全二叉树的节点个数计算

3.1 完全二叉树特性利用

完全二叉树除了最后一层外，其他层节点都达到最大值，且最后一层节点集中在左侧。利用这一特性可以避免遍历所有节点：

计算左右子树的高度
如果左右高度相同，则左子树是满二叉树，节点数为2^h - 1
如果高度不同，则右子树是满二叉树，节点数为2^(h-1) - 1
递归计算另一子树的节点数，加上根节点和满二叉树的节点数

3.2 高效算法实现

python复制def countNodes(root):
    if not root:
        return 0
    left_height = get_height(root.left)
    right_height = get_height(root.right)
    
    if left_height == right_height:
        return (1 << left_height) + countNodes(root.right)
    else:
        return (1 << right_height) + countNodes(root.left)

def get_height(node):
    height = 0
    while node:
        height += 1
        node = node.left
    return height

该算法的时间复杂度为O(log n * log n)，因为每次递归调用都会将问题规模减半，而计算高度需要O(log n)时间。

3.3 普通二叉树节点计数对比

对于普通二叉树，可以直接使用递归遍历所有节点：

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

这种方法简单直观，但时间复杂度为O(n)，对于完全二叉树来说不够高效。

4. 平衡二叉树判断

4.1 平衡二叉树定义

平衡二叉树是指任意节点的左右子树高度差不超过1的二叉树。判断二叉树是否平衡需要：

计算每个节点的左右子树高度
检查高度差是否大于1
递归检查所有子树是否都满足平衡条件

4.2 自顶向下与自底向上解法

自顶向下解法直观但效率较低，因为会重复计算高度：

python复制def isBalanced(root):
    if not root:
        return True
    left_height = height(root.left)
    right_height = height(root.right)
    return abs(left_height - right_height) <= 1 and \
           isBalanced(root.left) and \
           isBalanced(root.right)

def height(node):
    if not node:
        return 0
    return max(height(node.left), height(node.right)) + 1

自底向上解法更高效，在计算高度的同时判断平衡性：

python复制def isBalanced(root):
    return check_height(root) != -1

def check_height(node):
    if not node:
        return 0
    left_height = check_height(node.left)
    if left_height == -1:
        return -1
    right_height = check_height(node.right)
    if right_height == -1:
        return -1
    if abs(left_height - right_height) > 1:
        return -1
    return max(left_height, right_height) + 1

自底向上解法的时间复杂度为O(n)，空间复杂度为O(h)，h为树的高度。

5. 路径总和问题

5.1 问题描述与解法思路

路径总和问题要求判断二叉树中是否存在从根到叶子的路径，使得路径上所有节点值之和等于给定目标值。解决思路：

从根节点开始，递归检查左右子树
每次递归将目标值减去当前节点值
当到达叶子节点时，检查剩余目标值是否等于叶子节点值

5.2 递归实现与优化

基础递归实现：

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)

对于大规模树，可以添加提前终止条件：

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

5.3 迭代解法与路径记录

使用栈实现DFS并记录路径和：

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

如果需要记录所有满足条件的路径，可以修改为：

python复制def pathSum(root, targetSum):
    if not root:
        return []
    result = []
    stack = [(root, [root.val])]
    while stack:
        node, path = stack.pop()
        if not node.left and not node.right and sum(path) == targetSum:
            result.append(path)
        if node.right:
            stack.append((node.right, path + [node.right.val]))
        if node.left:
            stack.append((node.left, path + [node.left.val]))
    return result

6. 从中序与后序遍历序列构造二叉树

6.1 遍历序列特性分析

中序遍历：左子树 -> 根 -> 右子树
后序遍历：左子树 -> 右子树 -> 根

利用这两个特性可以唯一确定一棵二叉树：

后序遍历的最后一个元素是根节点
在中序遍历中找到根节点，左边是左子树，右边是右子树
递归构建左右子树

6.2 递归构造实现

python复制def buildTree(inorder, postorder):
    if not inorder or not postorder:
        return None
    root_val = postorder[-1]
    root = TreeNode(root_val)
    root_index = inorder.index(root_val)
    
    root.left = buildTree(inorder[:root_index], postorder[:root_index])
    root.right = buildTree(inorder[root_index+1:], postorder[root_index:-1])
    
    return root

6.3 优化与边界处理

上述解法每次递归都需要查找根节点位置和切片数组，可以通过哈希表优化：

python复制def buildTree(inorder, postorder):
    inorder_map = {val: idx for idx, val in enumerate(inorder)}
    
    def helper(in_start, in_end, post_start, post_end):
        if in_start > in_end:
            return None
        root_val = postorder[post_end]
        root = TreeNode(root_val)
        root_index = inorder_map[root_val]
        
        left_size = root_index - in_start
        root.left = helper(in_start, root_index - 1, post_start, post_start + left_size - 1)
        root.right = helper(root_index + 1, in_end, post_start + left_size, post_end - 1)
        
        return root
    
    return helper(0, len(inorder) - 1, 0, len(postorder) - 1)

这种方法将时间复杂度从O(n^2)降低到O(n)，空间复杂度为O(n)用于存储哈希表。

7. 二叉树算法实战技巧

7.1 递归转迭代的通用方法

虽然递归解法简洁，但在处理深度较大的树时可能导致栈溢出。将递归转为迭代的通用方法：

使用显式栈模拟函数调用栈
将递归函数的参数和局部变量封装为栈帧
手动管理栈的push和pop操作

例如，前序遍历的迭代实现：

python复制def preorderTraversal(root):
    if not root:
        return []
    stack, result = [root], []
    while stack:
        node = stack.pop()
        result.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return result

7.2 测试用例设计与验证

完善的测试用例应包含：

空树
单节点树
完全二叉树
非平衡树
单边倾斜树
随机生成的树

使用Python的unittest模块示例：

python复制import unittest

class TestTreeAlgorithms(unittest.TestCase):
    def test_minDepth(self):
        # 构建测试树
        root = TreeNode(1)
        root.left = TreeNode(2)
        self.assertEqual(minDepth(root), 2)
        
        root.right = TreeNode(3)
        root.right.right = TreeNode(4)
        self.assertEqual(minDepth(root), 2)
        
    def test_isBalanced(self):
        root = TreeNode(1)
        root.left = TreeNode(2)
        root.left.left = TreeNode(3)
        self.assertFalse(isBalanced(root))
        
        root.right = TreeNode(4)
        self.assertTrue(isBalanced(root))

7.3 性能优化与空间权衡

二叉树算法的常见优化策略：

记忆化：缓存已计算结果，避免重复计算
提前终止：找到解后立即返回，不继续搜索
迭代代替递归：避免栈溢出风险
利用树的性质：如完全二叉树、二叉搜索树等的特殊性质

在实际应用中，需要根据具体场景选择合适的方法。例如，对于频繁查询的平衡二叉树判断，可以为每个节点缓存高度信息，实现O(1)时间复杂度的查询，但需要额外的O(n)空间。