树形数据结构：从二叉树到平衡树的演进

原创

wx65dfdaaec020c 2025-08-24 09:11:49 博主文章分类：数据结构与算法 ©著作权

文章标签 子节点 python 二叉树 文章分类 Python 后端开发

©著作权归作者所有：来自51CTO博客作者wx65dfdaaec020c的原创作品，请联系作者获取转载授权，否则将追究法律责任

树形数据结构：从二叉树到平衡树的演进

摘要

树形数据结构是计算机科学中最重要的非线性结构之一，广泛应用于文件系统、数据库索引、编译器设计等领域。本文将系统介绍二叉树、二叉搜索树、平衡二叉树（AVL树、红黑树）以及堆等核心树结构，深入分析它们的特性、实现和应用。

1. 树的基本概念与术语

1.1 树的基本定义

树是由n(n≥0)个节点组成的有限集合，具有以下特性：

有一个称为根(root)的特殊节点
其余节点可分为m(m≥0)个互不相交的子树

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

1.2 重要术语

术语	说明	示例
节点	树的基本单位	包含数据和指针
边	节点间的连接	父节点到子节点的链接
根节点	没有父节点的节点	树的起点
叶节点	没有子节点的节点	树的终点
深度	根节点到该节点的边数	根节点深度为0
高度	节点到最深叶节点的边数	叶节点高度为0

2. 二叉树(Binary Tree)

2.1 二叉树特性

每个节点最多有两个子节点（左子节点和右子节点）

# 创建简单的二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

2.2 遍历算法

递归实现：

def preorder_traversal(root):
    """前序遍历：根→左→右"""
    if not root:
        return []
    return [root.val] + preorder_traversal(root.left) + preorder_traversal(root.right)

def inorder_traversal(root):
    """中序遍历：左→根→右"""
    if not root:
        return []
    return inorder_traversal(root.left) + [root.val] + inorder_traversal(root.right)

def postorder_traversal(root):
    """后序遍历：左→右→根"""
    if not root:
        return []
    return postorder_traversal(root.left) + postorder_traversal(root.right) + [root.val]

迭代实现：

def level_order_traversal(root):
    """层次遍历（广度优先）"""
    if not root:
        return []
    
    result = []
    queue = deque([root])
    
    while queue:
        level_size = len(queue)
        current_level = []
        
        for _ in range(level_size):
            node = queue.popleft()
            current_level.append(node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        result.append(current_level)
    
    return result

3. 二叉搜索树(BST)

3.1 BST特性

左子树所有节点值 < 根节点值
右子树所有节点值 > 根节点值
左右子树都是BST

3.2 基本操作实现

class BST:
    def __init__(self):
        self.root = None
    
    def insert(self, val):
        """插入操作"""
        if not self.root:
            self.root = TreeNode(val)
        else:
            self._insert(self.root, val)
    
    def _insert(self, node, val):
        if val < node.val:
            if node.left:
                self._insert(node.left, val)
            else:
                node.left = TreeNode(val)
        else:
            if node.right:
                self._insert(node.right, val)
            else:
                node.right = TreeNode(val)
    
    def search(self, val):
        """查找操作"""
        return self._search(self.root, val)
    
    def _search(self, node, val):
        if not node:
            return False
        if node.val == val:
            return True
        elif val < node.val:
            return self._search(node.left, val)
        else:
            return self._search(node.right, val)

4. 平衡二叉树

4.1 AVL树

通过旋转操作保持平衡的BST

class AVLNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
        self.height = 1

class AVLTree:
    def get_height(self, node):
        if not node:
            return 0
        return node.height
    
    def get_balance(self, node):
        if not node:
            return 0
        return self.get_height(node.left) - self.get_height(node.right)
    
    def left_rotate(self, z):
        y = z.right
        T2 = y.left
        
        y.left = z
        z.right = T2
        
        z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))
        y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
        
        return y
    
    def right_rotate(self, z):
        y = z.left
        T3 = y.right
        
        y.right = z
        z.left = T3
        
        z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))
        y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
        
        return y

4.2 红黑树 vs AVL树对比

特性	AVL树	红黑树
平衡标准	严格平衡	近似平衡
旋转次数	较多	较少
查询性能	更优	稍差
插入删除	较慢	较快
应用场景	读多写少	写操作频繁

5. 堆(Heap)结构

5.1 堆的特性

完全二叉树
父节点值 ≥ 子节点值（最大堆）
父节点值 ≤ 子节点值（最小堆）

5.2 堆的实现与应用

import heapq

# 使用Python内置堆
min_heap = []
heapq.heappush(min_heap, 3)
heapq.heappush(min_heap, 1)
heapq.heappush(min_heap, 2)
print(heapq.heappop(min_heap))  # 输出1

# 自定义最大堆
class MaxHeap:
    def __init__(self):
        self.heap = []
    
    def push(self, val):
        heapq.heappush(self.heap, -val)
    
    def pop(self):
        return -heapq.heappop(self.heap)
    
    def peek(self):
        return -self.heap[0]