数据结构——堆

呆瑜nuage2025-07-05 13:18

一.前言

现在，我们继续学习数据结构中的堆。堆是一种完全二叉树结构。为了更好地理解堆，现在就来学习一下吧

二.正文

(1)树

1.树的概念

在学习堆之前我们先来简单学习一下树的概念吧

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

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

**节点的度：**一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林；

2.树的表达

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系 ，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。最常用的孩子兄弟表示法。

复制代码 
typedef int DataType;
//孩子兄弟表示法
struct Node
{
	struct Node* firstChild1;//第一个孩子节点
	struct Node* pNextBrother;//下一个兄弟节点
	DataType data;
};

3.二叉树概念及结构

既然了解树了，我们紧接着来看看二叉树，二叉树由名字就可以知道一个节点有两个分叉。如图：

由上图，一棵二叉树是由节点构成的有限集合，它满足以下条件之一：

集合为空，包含一个根节点及其两棵子树（左子树和右子树），这两棵子树也是二叉树

二叉树具有重要特性：

每个节点的度不超过2，子树有明确的左右顺序且不可互换，因此二叉树属于有序树

4.特殊的二叉树

**1.满二叉树：**如果一个二叉树的每一层节点数都达到最大值，则称其为满二叉树。具体而言，对于深度为K的满二叉树，其节点总数为(2^K) - 1。

2.完全二叉树： 完全二叉树是一种高效的二叉树结构，由满二叉树引申而来。对于包含n个节点、深度为K的二叉树，当且仅当其节点与深度为K的满二叉树中编号1至n的节点一一对应时，称之为完全二叉树。值得注意的是，满二叉树是特殊的完全二叉树。

5.二叉树的性质

博主觉得这个还是有点重要的，在学校数据结构的考试中也是常出几题选择题等的。

性质：

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.

若规定根节点层数为 1，一棵非空二叉树第 5 层上最多有（ ）个结点。

A. 8

B. 15

C. 16

D. 32

解析：根据性质1，第 i 层最多有 2^(i - 1) 个结点 ， i = 5 时， 2^(5 - 1)=16 ，答案选C。

  1. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是(2^h)-1

规定根节点层数为 1，深度为 4 的二叉树，最大结点数是（ ）。
A. 7
B. 15
C. 31
D. 16
解析：由性质2，深度为 h 的二叉树最大结点数是 (2^h) - 1 ， h = 4 时， (2^4) - 1 = 15 ，答案选B。

  1. 对任何一棵二叉树, 如果度为0其叶结点个数为n0, 度为2的分支结点个数为n2,则有n0=n2+1

4.对任何一棵二叉树，边数 = 总节点数 N -1

已知一棵二叉树中，节点与节点之间的连线（边）总数为E，度为0的叶节点个数为n0，度为1的节点个数为n1，度为2的分支节点个数为n2。若该二叉树边数E = 25，且n1 = 3，则叶节点个数n0为（ ）
A. 12
B. 13
C. 14
D. 15

解析：1. 边数与度数：E = n1 + 2n2（边数是度1、2节点出边和 ，已知E = 25，n1 = 3，代入得25 = 3 + 2n2，算出n2 = 11， 用性质3：n0 = n2 + 1，代入n2 = 11，得n0 = 12，答案选A。

  1. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log(n+1) [底为2]

规定根节点层数为 1，一个满二叉树有 15 个结点，其深度 h 为（ ）（对数底为 2 ）。
A. 3
B. 4
C. 5
D. 6
解析：根据性质4，满二叉树深度 h = log₂(n + 1) ， n = 15 时， log₂(15 + 1)=log₂16 = 4 ，答案选B。

  1. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对 于序号为i的结点有（博主在考试中没遇到过这个题目，但是还是为大家找了一道题目）

6.1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点

6.2. 若2i+1=n否则无左孩子

6.3. 若2i+2=n否则无右孩子

对有 10 个结点的完全二叉树，按从上至下、从左至右从 0 开始编号，序号为 3 的结点，其双亲序号是（ ）。

A. 1

B. 2

C. 3

D. 4

解析：根据性质5第一条， i > 0 时，双亲序号为 (i - 1)/2 ， i = 3 时， (3 - 1)/2 = 1 ，答案选A 。

(2)堆

简单了解了一下树，这时候我们就可以来看看堆了。

1.堆的概念

堆是一种特殊的完全二叉树结构，其节点排列遵循特定的顺序规则。

大根堆

在大堆中，每个节点的值都大于或等于其子节点的值；

小根堆

在小堆中，每个节点的值都小于或等于其子节点的值。

堆通常用于实现优先队列，能高效地完成插入元素和删除最大（或最小）元素等操作。

2.堆的实现

准备工作就是建立三个文件，和前几篇文章一样，只是名字不同。让我们来看看要实现什么功能吧，放在Heap.h中

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

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}Heap;

//堆的初始化
void HeapInit(Heap* hp);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

2.1堆的初始化

复制代码 
//堆的初始化
void HeapInit(Heap* hp)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (hp->a == NULL)
	{
		perror("malllooc fail");
		return;
	}
	hp->size = 0;
	hp->capacity = 4;
}

2.2堆的销毁

复制代码 
// 堆的销毁
void HeapDestory(Heap* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}

2.3堆的检查并且扩容

复制代码 
//检查并且扩容
void HeapCheck(Heap* php)
{
	assert(php);
	if (php->size == php->capacity)
	{
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * (php->capacity) * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		php->a = tmp;
		php->capacity *= 2;

	}
}

上面这几个代码跟顺序表还是很像的，我相信对于大家来说还是可以很快上手的，接下来就是堆的重头戏，插入和删除。

2.4堆的插入

堆的插入采用向上调整法

1.当在大顶堆末尾添加新元素后，

2.需要从下往上比较新元素与其父节点：

如果新元素大于父节点，则交换两者位置，继续向上比较，直到新元素不大于父节点或到达堆顶

3.调整完后，确保堆的性质（大顶堆）得以维持

理解父子节点下标的关系至关重要。

已知子节点下标，如何计算父节点下标？

公式为：

parent = (child - 1) / 2

已知父节点下标，如何计算子节点下标？

公式为：
leftChild = parent * 2 + 1
rightChild = parent * 2 + 2

因为要交换多次所以直接写一个交换函数便于使用

复制代码 
//交换
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

向上调整法

复制代码 
//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆的插入

复制代码 
// 堆的插入
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	HeapCheck(php);

	php->a[php->size++] = x;
	AdjustUp(php->a, php->size - 1);
}

2.5堆的删除

堆的删除采用向下调整法

  1. 将堆的最后一个元素移到根节点位置

  2. 从根节点开始向下比较，与较大的子节点交换位置

  3. 持续调整直到当前节点大于等于左右子节点

  4. 最终堆大小减1，保持大顶堆性质

向下调整法

复制代码 
//向下调整法
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent * 2) + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = (parent * 2) + 1;
		}
		else
		{
			break;
		}
	}
}

堆的删除

复制代码 
// 堆的删除
void HeapPop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	AdjustDown(php->a, php->size, 0);
}

2.6堆的取堆顶的数据

复制代码 
// 取堆顶的数据
HPDataType HeapTop(Heap* php)
{
	assert(php);

	return php->a[0];
}

2.7堆的数据个数

复制代码 
// 堆的数据个数
int HeapSize(Heap* php)
{
	assert(php);

	return php->size;
}

2.8运行结果

3.堆的完整代码

复制代码 
#include "Heap.h"

//堆的初始化
void HeapInit(Heap* php)
{
	assert(php);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (php->a == NULL)
	{
		perror("malllooc fail");
		return;
	}
	php->size = 0;
	php->capacity = 4;
}

// 堆的销毁
void HeapDestory(Heap* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}

//检查并且扩容
void HeapCheak(Heap* php)
{
	assert(php);
	if (php->size == php->capacity)
	{
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * (php->capacity) * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		php->a = tmp;
		php->capacity *= 2;

	}
}

//交换
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

// 堆的插入
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	HeapCheck(php);

	php->a[php->size++] = x;
	AdjustUp(php->a, php->size - 1);
}

//向下调整法
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent * 2) + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = (parent * 2) + 1;
		}
		else
		{
			break;
		}
	}
}

// 堆的判空
bool HeapEmpty(Heap* php)
{
	assert(php);

	return php->size == 0;
}

// 堆的删除
void HeapPop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	AdjustDown(php->a, php->size, 0);
}

// 取堆顶的数据
HPDataType HeapTop(Heap* php)
{
	assert(php);

	return php->a[0];
}

// 堆的数据个数
int HeapSize(Heap* php)
{
	assert(php);

	return php->size;
}

(3)堆的应用

1.堆的排序

布骤：

  1. 建堆
  • 升序：建大堆
  • 降序：建小堆
  1. 利用堆删除思想来进行排序

1.为什么升序建大堆，降序建小堆了？

**升序排列时建大堆：**大堆的堆顶是最大值，每次将堆顶与堆尾元素交换，堆尾形成有序区（从大到小），剩余元素重新调整为大堆，最终堆尾有序区逆序后得到升序序列。

**降序排列时建小堆：**小堆的堆顶是最小值，每次将堆顶与堆尾元素交换，堆尾形成有序区（从小到大），剩余元素重新调整为小堆，最终堆尾有序区逆序后得到降序序列。
2.为什么上面图片用的是向下调整法，如果用向上调整法可以吗？(博主真不想画了，就借用一下我上课老师画的吧)

是可以用的，但是博主觉得向下更好一点，我们来看看向下或向上的调整的时间复杂度吧

|------|-------------------------|-------------------|
| | 向上调整法 | 向下调整法 |
| 操作方向 | 从叶子到根 | 从根到叶子 |
| 适用场景 | 堆插入 | 堆删除、建堆 |
| 复杂度 | 建堆O(n log n)，单次O(log n) | 建堆O(n)，单次O(log n) |
[向上调整法和向下调整法对比]

由对比图的复杂度就可以知道用向下更好一点

完整代码

复制代码 
void HeapSort(HPDataType* a, int n)
{
	//向下调整建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	//向上调整建堆
	//for (int i = 1; i < n; i++)
	//{
	//	AdjustUp(a, i);
	//}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

i=(n-1-1)/2为什么了？

最后一个非叶子节点的下标为n-1，再由这个公式**parent = (child - 1) / 2**，可得i=(n-1-1)/2，即从尾往前数的第一个父亲位置。

运行结果

2.TOP_K 问题

求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

基本思路：

  1. 用数据集合中前K个元素来建堆
  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆
  1. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

为什么求前k个最大的元素，则建小堆，前k个最小的元素，则建大堆？

  • 小顶堆的堆顶是堆中最小的元素。若要维护前k个最大元素，只需保证堆中始终存储当前最大的k个元素，且堆顶为其中最小的（即第k大元素），当遍历数组时，若当前元素大于堆顶，则替换堆顶并调整堆，确保堆中始终是"更大的k个元素"。若你用大堆，则堆顶是最大元素，可能让一些是前k个最大的元素进不去了。
  • 大顶堆的堆顶是堆中最大的元素。若要维护前k个最小元素，需保证堆中始终存储当前最小的k个元素，且堆顶为其中最大的（即第k小元素）。当遍历数组时，若当前元素小于堆顶，则替换堆顶并调整堆，确保堆中始终是"更小的k个元素"。若你用小堆，则堆顶是最小元素，可能让一些不是前k个最小的元素进去了。

完整代码

先创建数据

复制代码 
//造数据
void CreatData()
{
	int n = 10000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (size_t i = 0; i < n; i++)
	{
		int x = rand() % 10000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

打印

文件的知识点补充

1.fopen

**功能：**根据指定模式打开文件，返回文件指针（NULL表示打开失败）

|------|------------------------|
| "r" | 只读模式（文件需存在） |
| "w" | 写入模式（清空文件或创建新文件） |
| "a" | 追加模式（在文件末尾写入，文件不存在则创建） |
| "r+" | 读写模式（文件需存在） |
| "w+" | 读写模式（清空文件或创建新文件） |
[常用的mode参数]

注意事项：

  • 打开文件后必须检查返回值是否为NULL
  • 二进制文件需加 b （如 "wb" ），文本文件可省略
  • 文件名需包含路径（默认当前目录）】

2.fprintf

**功能：**按指定格式将数据写入文件流

使用示例：

FILE* fp = fopen("data.txt", "w");

fprintf(fp, "整数：%d，浮点数：%.2f\n", 100, 3.14);

与printf的区别：

  • printf 输出到标准输出（屏幕）， fprintf 输出到指定文件
  • 其他格式控制符（如 %d 、 %s ）完全一致
  • 返回值：成功写入的字符数，负数表示失败

3.fscanf

**功能：**按指定格式从文件流读取数据

使用示例：

FILE* fp = fopen("data.txt", "r");

int num;

fscanf(fp, "整数：%d", &num); // 读取"整数：100"中的100

与scanf的区别：

  • scanf 从标准输入（键盘）读取， fscanf 从指定文件读取
  • 格式控制需匹配文件中的数据格式
  • 返回值：成功读取的参数个数， EOF （-1）表示读取失败或文件结束

4.fclose

**功能：**刷新缓冲区并关闭文件，释放文件资源

注意事项：

  • 必须关闭所有打开的文件，避免数据丢失
  • 关闭后文件指针失效，不可再操作
  • 返回值为0表示成功，非0表示错误

缓冲区机制：

  • 写入文件的数据先存缓冲区，关闭时才真正写入磁盘
  • 若未关闭文件，可能导致缓冲区数据未保存

5.总结

  1. 打开文件：用 fopen 获取文件指针，检查是否打开成功

  2. 读写数据：

  • 写入：用 fprintf 按格式写入（类似 printf ）
  • 读取：用 fscanf 按格式读取（类似 scanf ）
  1. 关闭文件：用 fclose 释放资源，确保数据写入磁盘

代码

复制代码 
void PrintTopK(const char* file, int k)
{
	int* topk = (int*)malloc(sizeof(int) * k);
	if (topk == NULL)
	{
		perror("malloc fail");
		return;
	}

	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		free(topk);
		return;
	}

	//读出前k个数据建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &topk[i]);
	}

	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(topk, k, i);
	}

	//将剩下n-k个元素与堆顶进行交换，不满则替代
	int val = 0;
	int ret = fscanf(fout, "%d", &val);
	while (ret != EOF)
	{
		if (val > topk[0])
		{
			topk[0] = val;
			AdjustDown(topk, k, 0);
		}

		ret = fscanf(fout, "%d", &val);
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", topk[i]);
	}
	printf("\n");

	fclose(fout);
	free(topk);
}

int main()
{
	CreatData();
	PrintTopK("data.txt", 10);
	return 0;
}

三.总结

希望这些堆数据结构的知识能对你有所帮助！如果觉得实用，欢迎点赞支持~ 要是发现任何问题或有改进建议，也请随时告诉我。感谢阅读！

相关推荐
今天背单词了吗980几秒前
算法学习笔记：7.Dijkstra 算法——从原理到实战，涵盖 LeetCode 与考研 408 例题
java·开发语言·数据结构·笔记·算法
气质、小青年！8 分钟前
【排序算法】
c语言·数据结构
clock的时钟2 小时前
暑期数据结构第一天
数据结构·算法
小小小小王王王2 小时前
求猪肉价格最大值
数据结构·c++·算法
SuperW5 小时前
数据结构——队列
数据结构
??tobenewyorker5 小时前
力扣打卡第二十一天 中后遍历+中前遍历 构造二叉树
数据结构·c++·算法·leetcode
让我们一起加油好吗5 小时前
【基础算法】贪心 (二) ：推公式
数据结构·数学·算法·贪心算法·洛谷
蓝澈11215 小时前
迪杰斯特拉算法之解决单源最短路径问题
java·数据结构
蓝澈11218 小时前
弗洛伊德(Floyd)算法-各个顶点之间的最短路径问题
java·数据结构·动态规划
热门推荐
01Coze实战第13讲：飞书多维表格读取+豆包生图模型，轻松批量生成短剧封面02手机电脑之间快速传输图片视频文件，不压缩画质、不限制大小的方法！03Coze扣子平台完整体验和实践（附国内和国际版对比）04华为昇腾 910B 部署 DeepSeek-R1 蒸馏系列模型详细指南05免费可用！最强AI数字人对口型神器：让照片开口说话唱歌，支持多人对口型+全身动作，1分钟学会！（附保姆级教程）06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解072024年 最新 iPhone手机 历代机型、屏幕尺寸、纵横比、分辨率 整理08C#调用WechatOCR.exe实现本地OCR文字识别09DeepSeek各版本说明与优缺点分析10Coze平台 创建AI智能体的详细步骤指南