【深入浅出：非线性结构中的树——从二叉树到堆的实战指南】

最新推荐文章于 2025-08-05 20:53:10 发布

原创最新推荐文章于 2025-08-05 20:53:10 发布 · 592 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #决策树 #b树

Python、数据结构专栏收录该内容

13 篇文章

订阅专栏

深入浅出：非线性结构中的树——从二叉树到堆的实战指南

一、树结构的重要性

在计算机科学中，树结构就像现实世界的「组织结构图」，广泛应用于：

数据库索引（B树）
文件系统目录（多叉树）
游戏决策树（二叉树）
内存管理（堆）

二、二叉树（Binary Tree）

2.1 定义与特点

形状限制：每个节点最多有2个子节点（左/右）
数学表达：高度为 $h$ 的二叉树最多有 $2^h-1$ 个节点
经典类型：二叉搜索树（BST）、AVL树

2.2 Python实现

class TreeNode:
    def __init__(self, val=0):
        self.val = val
        self.left = None
        self.right = None

# 构建示例树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.right = TreeNode(4)

2.3 遍历方法

# 递归前序遍历
def preorder(root):
    if root:
        print(root.val)
        preorder(root.left)
        preorder(root.right)

# 迭代层次遍历
from collections import deque
def level_order(root):
    q = deque([root])
    while q:
        node = q.popleft()
        print(node.val)
        if node.left: q.append(node.left)
        if node.right: q.append(node.right)

2.4 常见问题与解决

问题现象	解决方案	代码示例
递归栈溢出	改用迭代遍历	使用栈/队列实现
内存占用高	使用线索二叉树	添加前驱/后继指针
查找效率低	转换为平衡树	AVL旋转操作

三、B树（B-Tree）

3.1 定义与特点

多路平衡： 每个节点最多m个子节点（m≥3）
数学规则： 根节点至少2个子节点，非根节点至少⌈m/2⌉个子节点
磁盘友好： 节点大小通常等于磁盘页大小（4KB）

3.2 Python简化实现

class BTreeNode:
    def __init__(self, keys=None, children=None):
        self.keys = keys or []
        self.children = children or []

class BTree:
    def __init__(self, degree=3):
        self.degree = degree
        self.root = BTreeNode()

    def insert(self, key):
        # 实现插入逻辑（包含节点分裂）
        pass

3.3 典型应用场景

数据库索引（MySQL的InnoDB引擎）
文件系统（NTFS、ReiserFS）
大数据存储（LevelDB）

四、堆（Heap）

4.1 定义与分类

结构特性： 完全二叉树
数学特性：
- 最大堆： 父节点值 ≥ 子节点值
- 最小堆： 父节点值 ≤ 子节点值
- 存储方式： 数组实现更高效

4.2 Python标准库使用

import heapq

# 创建最小堆
data = [3, 1, 4, 2]
heapq.heapify(data)

# 插入元素
heapq.heappush(data, 0)

# 提取最小值
print(heapq.heappop(data))  # 输出0

4.3 堆排序示例

def heap_sort(arr):
    heapq.heapify(arr)
    return [heapq.heappop(arr) for _ in range(len(arr))]

五、高频面试题解析

5.1 二叉树镜像问题

题目：反转二叉树的所有子节点

def invert_tree(root):
if root: # 基线条件：节点存在时操作
# 后序遍历递归 + 交换左右子树
	root.left, root.right = invert_tree(root.right), invert_tree(root.left)
return root # 返回当前子树的新根节点

递归是怎么进行的呢？当处理当前节点时，先递归地处理右子树和左子树。交换的时候，右边处理的结果赋给左边，左边处理的结果赋给右边。这样每一步都确保子树已经被反转，然后再交换。这应该是一个后序遍历的方式，因为先处理子节点再处理父节点。
不过，可能用户会疑惑为什么这样交换就能反转整个二叉树。比如，假设有一个二叉树，根节点有左右子节点，每个子节点又有自己的子节点。通过递归，每个节点都会被访问到，并且交换它们的左右子节点。这样，从最底层的叶子节点开始，逐层向上交换，最终整个树的结构就被反转了。
那递归的终止条件是什么呢？当传入的root是None的时候，递归就会停止返回None。这样，当某个节点没有子节点时，交换左右（都是None）不会有问题，直接返回自己。

     1
   /   \
  2     3
 / \   /
4   5 6
翻转过程：

1.递归到叶子节点 4, 5, 6，交换它们的左右子节点（无操作）。
2.回到节点 2，交换其左右子节点 4和 5。
3.回到节点 3，交换其左子节点 6（右子节点为空）。
4.回到根节点 1，交换其左右子节点 2和 3。

最终翻转后的树结构为：
     1
   /   \
  3     2
   \   / \
    6 5   4

5.2 B树与B+树对比

特性	B树	B+树
数据存储位置	所有节点	仅叶子节点
查询稳定性	不稳定	稳定
范围查询效率	低	高

5.3 堆的Top K问题

题目：从1亿个数字中找出最大的10个

首先，我应该先了解heapq.nlargest的功能。根据Python官方文档，heapq.nlargest(n, iterable, key=None)函数会从可迭代对象中返回前n个最大的元素，以降序排列。所以在这个函数中，n就是用户传入的k，iterable是输入的数组arr。


import heapq

def top_k(arr, k):
    return heapq.nlargest(k, arr)


核心作用：快速找出列表中前k个最大的元素，并按降序排列返回结果列表

1.底层实现原理
堆结构优化
- **最小堆机制**：维护大小为k的最小堆（堆顶始终是最小元素）
- **动态筛选**：遍历所有元素时，只保留比堆顶大的元素
- **时间复杂度**：O(n\logk)（n为数组长度）

2.与直接排序对比
| 方法              | 时间复杂度   | 空间复杂度 | 适用场景         |
|-------------------|------------|----------|----------------|
| heapq.nlargest    | O(n log k) | O(k)     | k远小于n时      |
| sorted(arr)[-k:]  | O(n log n) | O(n)     | k接近n时更高效   |

3.使用示例演示
data = [12, 45, 2, 78, 33, 90, 5]
print(top_k(data, 3)) # 输出[90, 78, 45]
print(top_k([], 5)) # 输出空列表[]
print(top_k(data, 0)) # 输出空列表[]