二叉树从入门到实践：堆与链式结构全解析

say_fall2026-02-19 8:40

欢迎来到 s a y − f a l l 的文章 欢迎来到say-fall的文章 欢迎来到say−fall的文章
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/d108ef9352824116adb18536eefb60bc.png) 🌈 say-fall：个人主页 🚀 专栏：《手把手教你学会C++》 | 《C语言从零开始到精通》 | 《数据结构与算法》 | 《小游戏与项目》 💪 格言：做好你自己，才能吸引更多人，与他们共赢，这才是最好的成长方式。

前言：

在数据结构的学习体系中，树结构是承上启下的核心内容 ------ 它既突破了线性结构（数组、链表、栈、队列）的一维限制，又为后续图结构的学习奠定基础。其中二叉树作为树结构中最具代表性的分支，因 "每个节点最多两个子节点" 的特性，成为解决排序、优先级调度、层次化数据处理等问题的关键工具。本文将从树的基础概念切入，逐步拆解二叉树的核心特性，并通过代码实现二叉堆（顺序存储）与链式二叉树（链式存储）的核心操作，帮助你从理论到实践掌握二叉树的本质与应用。

文章目录

正文：

一、树的基本知识

1. 直观的树

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

  • 有一个特殊的结点，称为根结点，根结点没有前驱结点
  • 除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
  • 因此，树是递归定义的。
  • 注意：树是不能够交叉的，一旦交叉就不能称之为树了

2. 树的相关概念

  • 结点的度：一个结点含有的子树的个数称为该结点的度； 如上图：A的为6
  • 叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等结点为叶结点
  • 非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等结点为分支结点
  • 双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
  • 孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
  • 兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
  • 树的度：一棵树中，最大的结点的度称为树的度； 如上图：树的度为6
  • 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
  • 树的高度或深度：树中结点的最大层次； 如上图：树的高度为4
  • 堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
  • 结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
  • 子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
  • 森林：由m（m>0）棵互不相交的树的集合称为森林；

3. 二叉树

树入其名，所谓二叉树就是每个节点最多有两个子节点的树，并且二叉树分左子树和右子树，是有序树

在二叉树中有两种特殊的二叉树：

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 2^K - 1，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

4. 二叉树的存储结构

与栈和队列一样，二叉树同样有着两种不同的结构，用来实现二叉树

顺序结构

顺序结构是按照二叉树排列的标号作为下标而存储的，从下图也能看出，二叉树的顺序结构只能够存储完全二叉树的数。二叉树顺序存储在物理 上是一个数组，在逻辑 上是一颗二叉树。

链式结构

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。

  • 下面我们来看一下两种结构的应用与实现

二、二叉堆的实现

1. 源代码仓库

完整实现代码已托管至Gitee，包含二叉堆的基本操作和堆排序实现：
二叉堆的实现

2. Heap.h 头文件解析

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
// 小顶堆声明
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>

// 类型定义
typedef int Hp_DataType;

// 堆结构体
typedef struct Heap {
    Hp_DataType* _a;     // 动态数组存储堆元素
    size_t _size;        // 当前堆大小
    size_t _capacity;    // 堆容量
}Heap;

// 函数声明
void HPInit(Heap* php);                      // 初始化堆
void HPDestroy(Heap* php);                   // 销毁堆
void Swap(Hp_DataType* p1, Hp_DataType* p2); // 交换元素
void HPPrint(Heap* php);                     // 打印堆
void HPPop(Heap* php);                       // 删除堆顶元素
void HPPush(Heap* php, Hp_DataType x);       // 插入元素
void Adjustup(Hp_DataType* a, size_t child); // 向上调整
void Adjustdown(Hp_DataType* a,int n, size_t parent); // 向下调整
Hp_DataType HPTop(Heap* php);                // 获取堆顶元素
bool HPEmpty(Heap* php);                     // 判断堆是否为空
void HeapSort(Hp_DataType* a, size_t sz);    // 堆排序

3. Heap.c 实现详解

基础操作
cpp 复制代码 
// 打印堆元素
void HPPrint(Heap* php) {
    assert(php);
    for(size_t i = 0; i < php->_size; i++) {
        printf("%d->", php->_a[i]);
    }
    printf("\n");
}

// 初始化堆
void HPInit(Heap* php) {
    assert(php);
    php->_a = NULL;
    php->_capacity = php->_size = 0;
}

// 销毁堆
void HPDestroy(Heap* php) {
    assert(php);
    free(php->_a);
    php->_a = NULL;
    php->_capacity = php->_size = 0;
}
核心算法
cpp 复制代码 
// 向上调整（插入时使用）
void Adjustup(Hp_DataType* a, size_t child) {
    assert(a);
    size_t parent = (child - 1) / 2;
    while(child != 0) {
        if(a[parent] < a[child]) {
            Swap(&a[parent], &a[child]);
            child = parent;
            parent = (child - 1) / 2;
        } else {
            return;
        }
    }
}

// 插入元素
void HPPush(Heap* php, Hp_DataType x) {
    assert(php);
    // 容量检查与扩容
    if(php->_capacity == php->_size) {
        size_t new_capacity = php->_capacity == 0 ? 4 : 2 * php->_capacity;
        Hp_DataType* tmp = (Hp_DataType*)realloc(php->_a, new_capacity*sizeof(Hp_DataType));
        if(tmp == NULL) {
            perror("push realloc fail");
            exit(1);
        }
        php->_a = tmp;
        php->_capacity = new_capacity;
    }
    // 插入并调整
    php->_a[php->_size] = x;
    php->_size++;
    Adjustup(php->_a, php->_size - 1);
}

// 向下调整（删除时使用）
void Adjustdown(Hp_DataType* a, int n, size_t parent) {
    assert(a);
    size_t child = 2 * parent + 1;
    while(child < n) {
        // 选择较大的子节点
        if(child + 1 < n && a[child + 1] > a[child]) {
            child++;
        }
        // 交换并继续调整
        if(a[parent] < a[child]) {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = 2 * parent + 1;
        } else {
            return;
        }
    }
}

// 删除堆顶元素
void HPPop(Heap* php) {
    assert(php);
    assert(php->_size > 0);
    // 交换首尾并调整
    Swap(&php->_a[0], &php->_a[(php->_size) - 1]);
    php->_size--;
    Adjustdown(php->_a, php->_size, 0);
}
堆排序实现
cpp 复制代码 
// 堆排序（降序）
void HeapSort(Hp_DataType* a, size_t sz) {
    int end = sz - 1;
   
    //向上调整建小堆
	//for (size_t i = 1; i < sz; i++)
	//{
	//	Adjustup(a, i);
	//}
	
	//向下调整建小堆
	int end = sz - 1;
	for (int i = (end-1)/2; i >= 0 ; i--)
	{
		Adjustdown(a, sz, i);
	}
   
    // 交换并调整
    for(size_t i = 0; i < sz; i++) {
        end = sz - i - 1;
        Swap(&a[0], &a[end]);
        Adjustdown(a, end, 0);
    }
    // 替代实现：
    //int end = n - 1;
	//while (end > 0)
	//{
	//	Swap(&a[0], &a[end]);
	//	AdjustDown(a, end, 0);
	//	--end;
	//}
}
测试用例
cpp 复制代码 
void test1() {
    Hp_DataType hp1[] = {4,2,8,1,5,6,9,7};
    Heap h1;
    HPInit(&h1);
    // 测试插入
    for(int i = 0; i < (sizeof(hp1)/sizeof(hp1[0])); i++) {
        HPPush(&h1, hp1[i]);
        HPPrint(&h1);
    }
    // 测试删除
    HPPop(&h1);
    HPPrint(&h1);
}

void test2() {
    // 测试堆排序
    Hp_DataType hp1[] = {4,2,8,1,5,6,9,7};
    HeapSort(hp1, sizeof(hp1)/sizeof(int));
    for(int i = 0; i < sizeof(hp1)/sizeof(int); i++) {
        printf("%d->", hp1[i]);
    }
}

int main() {
    test2();
    return 0;
}
算法分析

  1. 排序方式选择：

    • 降序：建小堆+头尾交换（从后往前变大）
    • 升序：建大堆+头尾交换（从后往前变小）

  2. 时间复杂度对比：

    • 向上调整建堆：O(n*logn)
    • 向下调整建堆：O(n)
    • 冒泡排序：O(n²)

  3. 应用场景：

    • 优先队列实现
    • 大规模数据排序
    • Top K问题求解

三、链式结构的二叉树

链式二叉树的基本概念

链式二叉树是一种非线性数据结构，通过指针将节点连接成树状结构。每个节点包含数据域和两个指针域，分别指向左子树和右子树。这种结构适合表示具有层次关系的数据，如文件系统、表达式树等。

Heap.h 头文件解析

cpp 复制代码 
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>


typedef int BT_DataType;

typedef struct BinaryTreeNode
{
	BT_DataType _val;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

//申请节点
BTNode* BuyNode(BT_DataType x);
//前序遍历
void PrevOrder(BTNode* root);
//中序遍历
void InOrder(BTNode* root);
//后序遍历
void PostOrder(BTNode* root);
//节点数
int BinaryTreeSize(BTNode* root);
//叶结点数
int BinaryTreeLeafSize(BTNode* root);
//第k层节点数
int BinaryTreeLevelKSize(BTNode* root, int k);
//树的高度
int BinaryTreeHeight(BTNode* root);
//查找
BTNode* BInaryTreeFind(BTNode* root, BT_DataType x);
void BInaryTreeFindtest(BTNode* root, BT_DataType x);
//层序遍历
void LevelOrder(BTNode* root);
// 二叉树销毁
void BinaryTreeDestory(BTNode* root);

Heap.c 实现详解

链式二叉树的节点结构

链式二叉树的节点通常定义为结构体，包含数据值和左右子节点指针：

c 复制代码 
typedef int BT_DataType;
typedef struct BTNode {
    BT_DataType _val;
    struct BTNode* _left;
    struct BTNode* _right;
} BTNode;

创建新节点

动态分配内存创建新节点，并初始化左右指针为NULL：

c 复制代码 
BTNode* BuyNode(BT_DataType x) {
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    node->_val = x;
    node->_left = NULL;
    node->_right = NULL;
    return node;
}

二叉树的遍历方式

前序遍历（根-左-右）
c 复制代码 
void PrevOrder(BTNode* root) {
    if (root == NULL) return;
    printf("%d ", root->_val);
    PrevOrder(root->_left);
    PrevOrder(root->_right);
}
中序遍历（左-根-右）
c 复制代码 
void InOrder(BTNode* root) {
    if (root == NULL) return;
    InOrder(root->_left);
    printf("%d ", root->_val);
    InOrder(root->_right);
}
后序遍历（左-右-根）
c 复制代码 
void PostOrder(BTNode* root) {
    if (root == NULL) return;
    PostOrder(root->_left);
    PostOrder(root->_right);
    printf("%d ", root->_val);
}
层序遍历（广度优先）

使用队列辅助实现：

c 复制代码 
void LevelOrder(BTNode* root) {
    Queue q;
    QueueInit(&q);
    if (root) QueuePush(&q, root);
    while (!QueueEmpty(&q)) {
        BTNode* front = QueueFront(&q);
        printf("%d ", front->_val);
        QueuePop(&q);
        if (front->_left) QueuePush(&q, front->_left);
        if (front->_right) QueuePush(&q, front->_right);
    }
    QueueDestroy(&q);
}

二叉树的基本操作

计算节点总数
c 复制代码 
int BinaryTreeSize(BTNode* root) {
    return root ? BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1 : 0;
}
计算叶子节点数
c 复制代码 
int BinaryTreeLeafSize(BTNode* root) {
    if (!root) return 0;
    return (root->_left == NULL && root->_right == NULL) 
        ? 1 
        : BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}
计算第K层节点数
c 复制代码 
int BinaryTreeLevelKSize(BTNode* root, int k) {
    if (!root) return 0;
    return (k == 1) ? 1 : BinaryTreeLevelKSize(root->_left, k-1) + BinaryTreeLevelKSize(root->_right, k-1);
}
计算树的高度
c 复制代码 
int BinaryTreeHeight(BTNode* root) {
    if (!root) return 0;
    int left = BinaryTreeHeight(root->_left);
    int right = BinaryTreeHeight(root->_right);
    return (left > right ? left : right) + 1;
}

二叉树的查找与判断

查找指定值的节点
c 复制代码 
BTNode* BInaryTreeFind(BTNode* root, BT_DataType x) {
    if (!root) return NULL;
    if (root->_val == x) return root;
    BTNode* left = BInaryTreeFind(root->_left, x);
    return left ? left : BInaryTreeFind(root->_right, x);
}
判断两棵树是否相同
c 复制代码 
bool isSameTree(BTNode* p, BTNode* q) {
    if (!p && !q) return true;
    if (!p || !q) return false;
    return p->_val == q->_val 
        && isSameTree(p->_left, q->_left) 
        && isSameTree(p->_right, q->_right);
}
判断是否为对称二叉树
c 复制代码 
bool _isSymmetric(BTNode* p, BTNode* q) {
    if (!p && !q) return true;
    if (!p || !q) return false;
    return p->_val == q->_val 
        && _isSymmetric(p->_left, q->_right) 
        && _isSymmetric(p->_right, q->_left);
}
bool isSymmetric(BTNode* root) {
    return _isSymmetric(root->_left, root->_right);
}

内存管理

销毁二叉树
c 复制代码 
void BinaryTreeDestory(BTNode* root) {
    if (!root) return;
    BinaryTreeDestory(root->_left);
    BinaryTreeDestory(root->_right);
    free(root);
}

应用场景

链式二叉树适用于需要频繁插入/删除节点的场景，如：

  • 表达式树的构建与求值
  • 文件系统的目录结构表示
  • 哈夫曼编码的树构建
  • 决策树等机器学习模型

注意：所有递归实现均可改为非递归实现（使用栈或队列），以避免栈溢出风险。

  • 本节完...
相关推荐
郝学胜-神的一滴2 小时前
Effective Modern C++ 条款38：线程句柄析构行为与Vibe Coding优化指南
开发语言·数据结构·c++·程序人生·多线程·并发
大闲在人10 小时前
C、C++区别还是蛮大的
c语言·开发语言·c++
掘根12 小时前
【C++STL】平衡二叉树（AVL树）
开发语言·数据结构·c++
瓦特what？12 小时前
快 速 排 序
数据结构·算法·排序算法
hetao173383712 小时前
2026-02-13~16 hetao1733837 的刷题记录
c++·算法
浅念-13 小时前
C++ string类
开发语言·c++·经验分享·笔记·学习
寻星探路14 小时前
【前端基础】HTML + CSS + JavaScript 快速入门（三）：JS 与 jQuery 实战
java·前端·javascript·css·c++·ai·html
忘梓.15 小时前
解锁动态规划的奥秘：从零到精通的创新思维解析（10）
c++·算法·动态规划·代理模式
热门推荐
01GitHub 镜像站点02从零搭建一个 PHP 登录注册系统（含完整源码）03使用 1panel面板 部署 php网站04openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南05MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法06AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot07让你的代码更整洁：10 个必知的 Kotlin 扩展函数08Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services09如何解决 OpenClaw “Pairing required” 报错：两种官方解决方案详解10openclaw 配置飞书 报错 应用未建立长连接