【数据结构初阶 6】二叉树：堆的基本操作 + 堆排序的实现

已于 2024-02-22 12:22:48 修改
阅读量1.5k 收藏 26
点赞数 40
分类专栏： 数据结构 - 实操版 文章标签： 数据结构 算法 c语言
于 2024-02-22 11:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shangguanxiu/article/details/136186312
版权

文章目录

🌈 Ⅰ 二叉树的顺序结构

1. 顺序存储结构概念

  • 顺序存储结构就是使用数组来存储二叉树的数据。
  • 这种结构下的逻辑结构是二叉树，物理结构是数组。
  • 数组内的值是将二叉树自上而下、自左而右依次存储，反过来数组构建二叉树也是这个顺序。

在这里插入图片描述

2. 顺序存储结构优势

使用这种结构可以很容易得出父子结点的下标。

  • 双亲结点下标 = ( 左或右孩子结点下标 - 1 ) / 2
  • 左孩子结点下标 = 双亲结点下标 * 2 + 1
  • 右孩子结点下标 = 双亲结点下标 * 2 + 2

3. 适合顺序存储的二叉树

  • 只有满二叉树或完全二叉树这种能够有效利用数组空间，适合使用顺序存储。

🌈 Ⅱ 堆的概念与性质

1. 堆的概念

  • 将一组数据构建成一棵完全二叉树，如果根节点的值 大于 / 小于 左右子树的所有值，则称该完全二叉树为一个堆。
  • 将根节点最大的堆称做大根堆；将根节点最小的堆称为小根堆。

2. 堆的性质

  1. 堆总是一棵完全二叉树。
  2. 有序数组一定是堆，反之却不一定。
  3. 小根堆：堆中所有双亲结点的值总是 <= 其孩子结点，根结点的值最小。
  4. 大根堆：堆中所有双亲结点的值总是 >= 其孩子结点，根结点的值最大。

在这里插入图片描述
在这里插入图片描述

🌈 Ⅲ 堆的基本操作

01. 堆的定义

  • 堆在计算机看来实际就是个数组，但不能只用数组表示堆，还需要记录下每个堆的有效数据个数以及对应堆的容量。
  • 因此就要建立一个堆的结构体来管理每个堆。
typedef int HPDataType;	// 堆中每个结点的数据类型

typedef struct Heap		
{
	int size;			// 记录数组中有效数据个数
	int capacity;		// 记录开辟的数组空间大小
	HPDataType* data;	// 为堆空间开辟的数组
}Heap;
  • 注意：因为 size 是用来记录堆中有效数据的个数，因此 size 天生是最后一个有效数据的后一个位置的下标。

02. 初始化堆

void HeapInit(Heap* hp)
{
	assert(hp);

	hp->data = NULL;
	hp->size = hp->capacity = 0;
}

03. 堆的销毁

void HeapDestory(Heap* hp)
{
	assert(hp);

	free(hp->data);
	hp->data = NULL;
	hp->size = hp->capacity = 0;
}

04. 堆的插入

  • 堆的本质实际上是个数组，因此往堆中插入数据就将数据尾插到数组中。
  • 当前有一组数据为 [68, 34, 49, 25, 18, 19, 15] 的数组构成的大根堆，往最后插入一个 10。

在这里插入图片描述

void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);

	if (hp->capacity == hp->size)		//是否要扩容
	{
		int newcapacity = hp->capacity = 0 ? 4 : 2 * hp->capacity;
		
		HPDataType* tmp = 
			(HPDataType*)realloc(hp->data, newcapacity * sizeof(HPDataType));
		assert(tmp);
		
		hp->capacity = newcapacity;
		hp->data = tmp;
	}

	hp->data[hp->size++] = x;			//插入新数据
	AdjustUp(hp->data, hp->size - 1);	//堆向上调整
}

05. 向上调整堆

1. 为何要向上调整堆

  • 插入数据之后可能导致破坏堆的结构，可能要对堆进行调整。
  • 往一个堆中插入不同的值时，需要判断会不会破会堆的结构。
    • 下图中，插入了 10 不会破坏大根堆，插入 100 却会。

在这里插入图片描述

2. 根据堆的性质判断是否要调堆

  • 小根堆中：只需要判断新插入的数据是否 < 其双亲结点的值，如果是则和其双亲结点交换。

  • 大根堆中：只需要判断新插入的数据是否 > 其双亲结点的值，如果是则和其双亲结点交换。

  • 在交换了之后，新结点可能比它双亲的双亲还 小 / 大，要一直交换到符合堆的定义为止。

    • 新结点 100 和它的双亲交换之后还是大于其新的双亲，要交换到符合堆定义为止。

  • 如下图所示的将 100 向上调整到它最终位置，即为堆的向上调整。

在这里插入图片描述

3. 堆的向上调整实现思路

  • 定义的函数形参 data 是一个存储堆中数据的数组，child 是新插入的结点的下标。
  • 算出新结点的双亲结点，然后与其双亲结点比较，如果不符合 大 / 小根堆的定义则交换。
  • 交换了之后原来双亲结点的位置就变为了新结点的位置，再算出该结点新的双亲结点去比较。
  • 当将新结点向上调整到符合 大 / 小 根堆的定义时停止调整，最坏情况新结点会被调成根结点。

4. 堆的向上调整代码实现

  • 该代码适用于调成 大 / 小 根堆。
void AdjustUp(HPDataType* data, int child)		// 向上调整堆
{
	int parent = (child - 1) / 2;				// 算出新结点的双亲结点

	while (child > 0)							// 最坏情况新结点会被调成根结点
	{
		// if (data[child] < data[parent])		// 按照 小根堆 定义向上调整
		if (data[child] > data[parent])			// 按照 大根堆 定义向上调整
		{
			swap(&data[child], &data[parent]);	// 交换双亲和孩子结点的数据
			child = parent;						// 原双亲结点的位置给了新结点
			parent = (parent - 1) / 2;			// 求新结点双亲的双亲的位置
		}
		else									// 结点被调到符合 大/小 根堆
		{
			break;								
		}
	}
}

06. 堆的创建

实现思路

  • 将一组数据从第一个开始依次进堆，每放一个数据进堆就调用一次向上调整算法。
    • 当前有一组数据，将它们依次插入进堆，然后调用向上调整算法。

在这里插入图片描述

代码实现

int main()
{
	int test[] = {85,9,1,7,6,7,5,45,13,54};
	size_t size = sizeof(test) / sizeof(test[0]);

	Heap hp;
	HeapInit(&hp);

	// 将 test 数组内的值依次插入进堆
	for (int i = 0; i < size; i++)
	{
		HeapPush(&hp, test[i]);
	}

	return 0;
}

07. 获取堆顶数据

  • 数组的 0 号位置就是堆顶元素，直接返回该位置的值即可。
HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(hp->size > 0);	// 堆中有元素可被获取

	return hp->data[0];		// 堆中结点的值不一定是 int 类型
}

08. 堆的删除

  • 堆的删除规定删除根结点的数据，即删除堆顶结点。

实现思路

  • 将堆顶元素和堆尾元素交换，然后将堆中有效数据个数 -1 即可实现删除。

在这里插入图片描述

代码实现

void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->size > 0);							// 堆中有元素

	swap(&hp->data[0], &hp->data[hp->size - 1]);	// 堆顶和堆尾互换
	hp->size--;										// 删除最后一个元素
	AdjustDown(hp->data, hp->size, 0);				// 将堆顶元素向下调整
}

09. 向下调整堆

1. 为何要向下调整堆

  • 某些情况下，堆中的某一个非叶子结点可能要比其孩子结点 大 / 小，不符合 小 / 大 根堆的定义。
    • 如上图：将 9 换到根结点之后明显就破坏了大根堆的结构，要将其向下调整到合适位置。

2. 向下调整实现思路

  1. 比较要下沉的结点 k 的左右孩子的值，找出值较 大 / 小 的那个孩子出来。
  2. 如果是大根堆，就用最大孩子和 k 互换；如果是小根堆，就用最小孩子和 k 互换。
  3. 重复上述步骤，直到将 k 调到它应在的位置即可。

在这里插入图片描述

3. 向下调整代码实现

  • 按照小根堆的定义向下调整
void AdjustDown(HPDataType* data, int size, int parent)
{
	int child = parent * 2 + 1;	// 假设是结点的左孩子比较小

	while (child < size)		// 不能超过数组的范围
	{
		// 如果右孩子 < 左孩子，则最小孩子结点换成右孩子
		if (child + 1 < size && data[child + 1] < data[child])
		{
			child++;
		}

		//最小孩子结点 < 其双亲结点则要交换
		if (data[child] < data[parent])
		{
			swap(&data[child], &data[parent]);
			child = child * 2 + 1;
			parent = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
  • 按照大根堆的定义向下调整，将两个 if 里用于比较左右孩子大小的 < 换成 > 即可。
    • 第一个 if：将 data[child + 1] < data[child] 换成 data[child + 1] > data[child]
    • 第二个 if：将 data[child] < data[parent] 换成 data[child] > data[parent]
void AdjustDown(HPDataType* data, int size, int parent)
{
	int child = parent * 2 + 1;	// 假设是结点的左孩子比较大

	while (child < size)		// 不能超过数组的范围
	{
		// 如果右孩子 > 左孩子，则最大孩子结点换成右孩子
		if (child + 1 < size && data[child + 1] > data[child])
		{
			child++;
		}

		//最大孩子结点 > 其双亲结点则要交换
		if (data[child] > data[parent])
		{
			swap(&data[child], &data[parent]);
			child = child * 2 + 1;
			parent = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

10. 判断堆空

  • 判断堆中有效数据的个数是否为 0 即可。
int HeapEmpty(Heap* hp)
{
	assert(hp);

	return 0 == hp->size;
}

🌈 Ⅳ 堆的基本应用

01. 堆排序的实现

排序思路

  • 事先声明：排升序用大根堆，排降序用小根堆 (默认为升序)
  1. 将待排序的 n 个数据使用向下调整造成一个大根堆，此时堆顶就是整个数组的最大值。
  2. 将堆顶和堆尾互换，此时堆尾的数就变成了最大值，剩余的待排序数组元素个数为 n - 1 个。
  3. 将剩余的 n - 1 个数调整回大根堆，将新的大根堆的新的堆顶和新的堆尾互换。
  4. 重复执行上述步骤，即可得到有序数组。

举个例子

  • 当前有数据为 [ 8, 9, 4, 74, 12, 15, 6 ] 现对其进行升序排序，要先构成大根堆。

在这里插入图片描述

代码实现

  • data 指向原数组空间，n 表示要排序的数据个数。
// 排成升序
void HeapSort(int* data, int n)
{
	int i = 0;
	int end = n - 1;

	// 从最后一个非叶子结点开始依次往前向下调整构建大根堆
	// n - 1 是最后一个结点的下标，(n - 1 - 1) / 2 是最后一个结点的夫结点下标
	// 也就是最后一个非叶子结点
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		// 要使用建大堆的向下调整算法
		AdjustDown(data, n, i);
	}

	// 0 和 end 夹着的是待排序数据，end 是待排序数据的个数
	// 每次都选出一个最大的数放到 end 处，然后待排序数据个数 end - 1
	while (end > 0)
	{
		swap(&data[0], &data[end]);	// 互换堆顶和堆尾的数据
		AdjustDown(data, end, 0);	// 从根位置 (0) 开始的向下调整
		end--;						// 缩小待排序数据区间，且个数 - 1
	}
}

02. TOP K 问题

问题概述

  • 在 n 个数中找出最大 / 最小的前 k 个数 (前提：n 远大于 k)

实现思路

  1. 用这 n 个数的前 k 个数来构建一个堆，这个堆就只有 k 个数。
    • 求前 k 个最大的元素，就建小根堆。
    • 求前 k 个最小的元素，就建大根堆。
  2. 用剩余的 n - k 个元素依次与堆顶元素比较。
    • 求前 k 个最大的元素，就用比小根堆顶 大 的数和其互换，然后向下调整堆。
    • 求前 k 个最小的元素，就用比大根堆顶 小 的数和其互换，然后向下调整堆。

举个栗子

  • 当前有如下一组数据，现求其最大的前 3 个数
    • [ 4, 6, 5, 2, 3, 7, 9, 1, 8 ]
  • 建成小堆能将后面比堆顶小的数全部挡在外面，最后堆中剩下的 3 个值就是最大的那三个。

在这里插入图片描述

代码实现

void TopK(int* data, int n, int k)
{
	int i = 0;
	int j = 0;
	HPDataType* MinHeap = (HPDataType*)malloc(sizeof(HPDataType) * k);
	assert(MinHeap);

	for (i = 0; i < k; i++)				// 将前 k 个数先插入进堆中
	{
		MinHeap[i] = data[i];
	}
	
	for (i = (k - 2) / 2; i >= 0; i--)	// 将这 k 个数的堆向下调整成小根堆
	{
		AdjustDown(MinHeap, k, i);
	}
	
	for(j = k; j < n; j++)				// 将 k 之后的数据依次和堆顶比较
	{
		if (MinHeap[0] < data[j])		// 后续数据大于堆顶则和堆顶互换后调整
		{
			MinHeap[0] = data[j];
			AdjustDown(MinHeap, k, 0);
		}
	}
}
♬咖啡猫♬
关注
  • 40
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【初阶数据结构】完全二叉树实现堆排序
m0_52751535的博客
09-03 649
堆排序算法一、完全二叉树的介绍二、堆向下调整算法三、堆排序算法 前言 完全二叉树是效率很高的数据结构，用它进行排序算法时时间复杂度大大降低 一、完全二叉树的介绍 完全二叉树是由满二叉树引出来的。对于深度为K，有n个结点的二叉树，当且仅当其每一个节点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。满二叉树是一种特殊的完全二叉树。 如上图示为满二叉树，深度K为3，结点n为7，即满二叉树的结点n与深度K存在关系为：n = 2^k - 1. 如上图示为完全二叉树，完全二叉树有如下性质：
数据结构:二叉树及堆排序
m0_64240499的博客
08-12 474
二叉树初阶及堆排序
《数据结构初阶》二叉树之堆的实现和堆排序
m0_62171658的博客
04-04 1632
本章重点介绍堆概念、堆的相关接口、堆排序（含有动态图）
数据结构初阶之二叉树——堆排序
Britney_dark的博客
06-08 870
我但愿那些人能一直欢笑。
【数据结构初阶】树+二叉树+堆的实现+堆的应用
The porters of knowledge
11-19 1171
堆的顺序结构实现+应用
数据结构与算法初阶7：基于二叉树的堆和堆排序知识精讲
King_lm_Guard的博客
07-21 321
数据结构与算法初阶7：堆和堆排序精讲。
【数据结构初阶】二叉树——堆的应用（堆排序 + TOP-K问题）
Clumsy、笨拙的博客
09-07 4154
上一篇我们讲了二叉树的概念，以及堆的结构和实现。不了解的进行了解。本篇，博主分享的是堆的应用。
【数据结构初阶】：堆的接口实现和堆排序
平凡的指针的博客
11-15 777
文章目录堆的实现一、堆的概念及结构二、堆的实现思路三、堆的各种接口：1.堆的初始化和销毁2.堆的插入3.堆的删除4.打印堆的数据和获取堆顶的元素5.获取堆的元素个数和判空堆排序1.向上调整建堆2.向下调整建堆3.建堆后的堆排序4.建堆的时间复杂度证明 堆的实现 一、堆的概念及结构 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 (kik_{i}ki​ <= k2i
C语言【数据结构】二叉树实现堆及堆排序
冰果滴的博客
04-15 1907
前言：这一篇先用完全二叉树来实现堆及堆排序，下一篇将会把整个初阶的二叉树完结。 一.二叉树的顺序结构及堆的概念 1.二叉树的顺序结构 普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。 2.堆的概念及结构 （1）堆的概念 如果有一个集合K = { k0，k1 ，k2.
数据结构：堆排序(升序排序建大堆)，TOP-K问题
10-06
堆排序(升序排序建大堆)，TOP-K问题，创建一个文本将随机数放入，取最大的前100个数
数据结构实验：二叉树的基本操作
12-04
南邮数据结构实验使用C++描述，二叉树的基本操作
数据结构实验-二叉树的基本操作
10-26
运用二叉链表实现二叉树的基本操作，包括：创建二叉树的存储结构、复制已有的二叉树、计算已有的二叉树的深度、先根序序列、中根序序列、后根序序列等。 输入格式：AB#C##D## 二、实验目的 掌握二叉链表及二叉树的...
完全二叉树，堆操作c语言实现
04-10
内容概要：堆的常用操作，包括创建、销毁、添加、插入、删除、空堆、满堆、堆顶 阅读建议：推荐有一定的数据结构基础，对于c语言敏感性高，对指针学习感兴趣
头歌数据结构二叉树的顺序存储及基本操作
05-18
头歌数据结构二叉树的顺序存储及基本操作 第1关树和二叉树基本概念 第2关二叉树的顺序存储及基本操作 在计算机科学中，二叉树是每个节点最多只有两个分支的树结构，即每个节点的分支度不大于2。通常分支被称作左...
数据结构进阶——并查集
weixin_73870552的博客
06-10 986
数据结构进阶——并查集。
【Chrome插件】如何在Chrome插件开发中处理复杂数据结构的存储
Yong.Sunshine
06-12 322
最近俺在接触 Chrome 插件开发，需要把一个数据存放到浏览器的存储中。这个数据结构有点复杂，它包含一个 Map 和一个数组。我使用 chrome.storage.local API来存储这个数据，然后在另一个地方获取数据。保存数据的代码并没有报错，但是俺发现获取的时候获取结果的内容为空，这是为什么呢？
java算法：冒泡排序
最新发布
weixin_45832694的博客
06-13 576
然而，尽管这些优化方法可以减少比较和交换的次数，冒泡排序的时间复杂度仍然是O(n^2)，因此对于大规模数据集来说，并不是最优的排序算法选择。传统的冒泡排序是从左到右逐个比较并交换相邻元素的位置，而鸡尾酒排序是交替进行从左到右和从右到左的遍历，将较大的元素从末端冒泡到首端，再将较小的元素从首端冒泡到末端。在每一趟遍历中，通过记录最后一次交换的位置，将该位置作为下一趟遍历的边界。为了优化冒泡排序，可以引入一个标志变量来记录是否发生了交换操作，如果某一趟遍历中没有发生交换，就说明数组已经有序，可以提前结束排序。
数据结构-二叉树
passworddddddd的博客
06-12 296
树（Tree）是一种非常重要的数据结构，它模拟了一种层级或者分支结构。在树结构中，数据以节点（Node）的形式存储，并且每个节点都可以有零个或多个子节点。除了二叉树最后一层，其他各层的节点数都达到最大个数，且最后一层从左向右的叶节点连续存在，只缺右侧若干节点。完美二叉树是特殊的完全二叉树。除了最下一层的叶子节点外，每层节点都有两个子节点，就构成了满二叉树。如果树中每个节点最多只能有两个子节点，这样的树就称之为二叉树。
数据结构二叉树的基本操作及利用c语言实现
04-28
二叉树是一种重要的数据结构，它有多种基本操作，包括创建二叉树、插入节点、删除节点、查找节点等。以下是二叉树的基本操作及使用 C 语言实现： 1. 创建二叉树 创建二叉树的基本思路是：先创建根节点，然后递归地创建左右子树。以下是实现代码： ```c // 定义二叉树结构体 typedef struct TreeNode { int val; struct TreeNode* left; struct TreeNode* right; } TreeNode; // 创建二叉树 TreeNode* createTree(int val) { TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode)); root->val = val; root->left = NULL; root->right = NULL; return root; } ``` 2. 插入节点 插入节点的基本思路是：先找到插入的位置，然后插入节点。以下是实现代码： ```c // 插入节点 void insert(TreeNode* root, int val) { if (root == NULL) { root = createTree(val); } else if (val < root->val) { if (root->left == NULL) { root->left = createTree(val); } else { insert(root->left, val); } } else { if (root->right == NULL) { root->right = createTree(val); } else { insert(root->right, val); } } } ``` 3. 删除节点 删除节点的基本思路是：先找到待删除的节点，然后判断该节点的子树情况，分三种情况进行处理。以下是实现代码： ```c // 删除节点 TreeNode* delete(TreeNode* root, int val) { if (root == NULL) { return NULL; } if (val < root->val) { root->left = delete(root->left, val); } else if (val > root->val) { root->right = delete(root->right, val); } else { if (root->left == NULL && root->right == NULL) { free(root); return NULL; } else if (root->left == NULL) { TreeNode* temp = root->right; free(root); return temp; } else if (root->right == NULL) { TreeNode* temp = root->left; free(root); return temp; } else { TreeNode* temp = root->right; while (temp->left != NULL) { temp = temp->left; } root->val = temp->val; root->right = delete(root->right, temp->val); } } return root; } ``` 4. 查找节点 查找节点的基本思路是：从根节点开始，递归地搜索左右子树，直到找到目标节点或者到达叶子节点。以下是实现代码： ```c // 查找节点 TreeNode* search(TreeNode* root, int val) { if (root == NULL) { return NULL; } if (root->val == val) { return root; } else if (val < root->val) { return search(root->left, val); } else { return search(root->right, val); } } ``` 以上是二叉树的基本操作及使用 C 语言实现的代码。需要注意的是，这里的代码仅仅是示例代码，实际使用时需要根据具体需求进行修改和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值