数据结构-堆的创建（详解）

最新推荐文章于 2024-09-07 15:47:21 发布
最新推荐文章于 2024-09-07 15:47:21 发布
阅读量1k 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73142957/article/details/131574419
版权

目录

堆的概念及结构

 堆的实现

堆的向上调整算法

代码实现：

思路详解：

 堆的向下调整算法

代码实现：

思路详解：

堆的创建：

堆结构的定义及相关函数的声明：

堆的初始化：

堆的销毁：

堆的插入：

堆的删除：

取得堆顶元素：

堆的判空：

堆中元素的个数：

向上调整算法：

向下调整算法：

交换： 

堆的概念及结构

堆：1 完全二叉树

任何一个数组都可以看成一个完全二叉树，所以堆的物理结构就是数组，逻辑结构是一颗完全二叉树

       2 大堆：树中任何一个父亲都大于或者等于孩子

          小堆：树中任何一个父亲都小于或者等于孩子

3 父子下标关系 leftchild = parent*2+1   rightchild = parent*2+2

                         parent = （child-1)/2

 堆的实现

堆的向上调整算法

代码实现：

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整算法--建小堆
void AdjustUp(int* 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;
		}
		
	}
}

思路详解：

向上调整建堆其实就是一个插入的过程，向上调整算法的前提是插入之前，已经是堆

下面我以建小堆的思路来介绍：

 每插入一个元素，可能需要多次向上调整，即可能会与自己所有的祖先节点比较，首先和其父亲 （下标是：（child-1)/2 ）比较，若是小于父亲则二者交换，此元素作为孩子向上调到父亲的位置，然后再和这个位置上的父亲比较，过程一样……，若是大于父亲则无需向上调堆，位置合适

孩子节点何时停止向上调整 ？

 1 孩子节点处在合适的位置 即孩子节点大于父亲节点

or:孩子节点调整至堆顶，调无可调

 插入的孩子60比父亲56大，位置合适，插入后还是小堆，无需向上调整

插入的孩子50小于其父亲56，需要向上调整：

孩子50和父亲56交换位置，现在孩子50处在父亲56的位置，然后求出孩子50现在的下标，即child=parent，继而求出孩子50现在的父亲下标 parent = （child-1)/2 

孩子50小于现在的父亲10，位置合适，结构保持为堆，无需继续向上调整

 

孩子8比父亲56小，向上调整，调到父亲56的位置，继续与现在位置上的父亲10比较，小于，向上调整， 调到父亲10的位置，此时已经处在堆顶，下标为0，无需继续调堆

 堆的向下调整算法

代码实现：

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整算法--建小堆
void AdjustDown(int* a, int n,int parent)
{
	int child = parent * 2 + 1;//假设左右孩子中最小的孩子是左孩子
	while (child < n)//只要一个父亲节点还有左孩子，则有继续向下调整的可能
	{
		if (child + 1 < n && a[child + 1] < a[child])//右孩子存在且右孩子<左孩子，假设不成立，更换有孩子为最小的孩子，child更新为右孩子的下标，右孩子的下标为左孩子的下标+1
		{
			child++;
		}

		if (a[child] < a[parent])//左右孩子中最小的孩子比父亲小，交换二者位置
		{
			Swap(&a[child], &a[parent]);
			parent = child;//父亲节点现在处在最小孩子的位置
			child = parent * 2 + 1;//父亲节点现在最小孩子（依然先做假设）
		}
		else//左右孩子中最小的孩子都比父亲节点大，父亲节点无需向下调整，位置合适，保持小堆
		{
			break;
		}
	}
}

思路详解：

向下调整算法有一个前提：左右子树必须是一个堆，才能调整

1 从父节点开始向下调整

  先选出左右孩子中最小/最大的一个，然后与其比较：下面我按小堆的形式介绍

  若是父亲小于孩子中最小的一个，则无需向下调整

  若是父亲大于孩子中最小的一个，则二者交换，父亲调至最小孩子的位置

  再求出它现在最小孩子的下标，二者比较，重复上述过程

2 父节点何时停止向下调整：

  父节点处在合适的位置，父节点小于最小的孩子

or：父节点调至叶子节点，调无可调，此时的父节点是没有左孩子的，故而当父亲的要与之交换的孩子下标越界后，就无需再向下调整了

                                          

 

 

 

 

 

堆的创建：

堆结构的定义及相关函数的声明：

堆是一颗完全二叉树，任何一个数组都可以看成一颗完全二叉树，所以堆结构就可以用数组来实现

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;

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

void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
bool HeapEmpty(HP* php);
int HeapSize(HP* php);

void AdjustUp(HPDataType* a, int child);
void AdjustDown(int* a, int n, int parent);

堆的初始化：

void HeapInit(HP* php)
{
	assert(php);//断言，确保堆指针不为空
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

堆的销毁：

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

堆的插入：

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)//空间满了需要扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(int) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}

	php->a[php->size] = x;
	php->size++;
	AdjustUp(php->a, php->size - 1);//每插入一个元素需要向上调整，以保持堆结构
}

堆的删除：

删除的是堆顶的元素，方法是：

1 将堆顶元素与最后一个元素交换

2 删除最后一个元素，即实现删除堆顶元素的效果

3 从现在的堆顶位置开始向下调整，以维持堆结构不变

void HeapPop(HP* 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(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));//为空不能取数据
	return php->a[0];
}

堆的判空：

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

堆中元素的个数：

int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

向上调整算法：

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 AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

交换： 

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

现在我们来使用这个堆结构吧，将数组建成一个小堆，不断打印堆顶元素我们会得到一个递增序列，但注意！！建成小堆后数组任然无序，因为堆只规定了父子间的关系，没有规定兄弟间的关系

得到最小的堆顶元素后，删除堆顶元素，新交换到堆顶的元素向下调整，会得到第二小的元素，然后是第三小，第四小……所以不断打印堆顶元素会是有序序列

int main()
{
	HP heap;
	HeapInit(&heap);
	int arr[] = { 9,8,7,6,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		HeapPush(&heap, arr[i]);
	}

	while (!HeapEmpty(&heap))
	{
		int Top = HeapTop(&heap);
		HeapPop(&heap);
		printf("%d ", Top);
	}

	HeapDestroy(&heap);
	return 0;
}

堆中的元素：物理结构如上

可以看到数组成为小堆后仍然不是有序的

逻辑结构图：

不断打印堆顶元素，得到一个递增序列：

 

 完结撒花~

Artiel
关注
专栏目录
堆的构建
qq_43941389的博客
04-14 2920
堆的定义: 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做大根堆，根节点最小的堆叫做小根堆。 堆的特性: 堆中某...
Java数据结构----堆的概念及结构
weixin_43224539的博客
05-02 2827
二叉树有两种实现结构,一种是链式结构(详解在上一篇),一种就是顺序结构,普通二叉树其实是不适合用数组来存储数据,因为会造成大量空间的浪费,但完全二叉树似乎更合适于顺序结构存储,我们通常把堆(完全二叉树)使用顺序数组来存储 1. 什么是堆? 堆就是将一个集合的数据按照完全二叉树的顺序结构存储在一个一维数组中,堆在逻辑上是一棵完全二叉树,在物理结构上是一个一维数组. 按照根结点的大小分为大堆(根...
建堆过程
热门推荐
学仙只为看看天的专栏
10-12 3万+
堆排序中，最初的步骤就是建立一个堆。之前在一些公司的笔试题上面见到一些与建堆过程相关的题目，因为当时对建堆过程有个误解，所以经常选错。之前一直以为是在完全二叉树中依次插入序列中的元素，每插入一个元素，就调用siftup操作；而实际的建堆操作是序列中元素首先就全部填入一个完全二叉树，然后从第一个非终端节点开始，调用siftdown操作，依次调整。 以下是一篇关于建堆过程的文章，转载自：http:/
数据结构之堆的创建
最新发布
m0_74862890的博客
09-07 1088
堆的实现，堆的向上调整算法，堆的向下调整算法
堆的建立
Let_life_stop的博客
08-17 536
模板题： #include&lt;bits/stdc++.h&gt; using namespace std; int n,m; int a[11]; void update(int t) { int i; while(t*2&lt;=m)//当这个值还有子节点时进行下列循环 { if(a[t*2]&lt;a[t]) { ...
数据结构C语言排序方法-堆排序详解！.pdf
01-15
【数据结构】C语言排序方法——堆排序详解 堆排序是一种基于比较的排序算法，它利用了二叉堆这一数据结构的特点。堆是一种特殊的树形数据结构，形状近似完全二叉树，同时满足堆积性质：在最大堆中，每个父节点的值...
SCAU数据结构-STL详解-20210609.pptx
06-25
此外，还有拷贝算法如copy、unique去除重复元素，以及heap相关操作如make_heap、push_heap、pop_heap等，用于创建和管理堆数据结构。 模板是STL的关键特性，它使得这些组件能够处理任意类型的数据。例如，函数模板...
数据结构--堆的要点、实现以及建堆时间复杂度证明
qq_53215123的博客
05-16 973
文章目录堆排序要点总结建堆详细时间复杂度证明实现代码（python）小根堆测试代码（堆排序正确性测试） 堆排序要点总结 堆的两个要素：是完全二叉树并且父节点的值一定大于（大根堆）或小于（小根堆）它的左右孩子。所有的操作，仔细思考后会发现，都是为绕这两点在做功课。   构建时使用的基础数据结构，一般使用数组模拟完全二叉树，模拟方法： 1号元素即为根节点 对于一个编号为n的节点，其左子节点编号为 2n,其右子节点编号为 2n + 1，其父节点编号为 n // 2 如果总结点数为n，则
数据结构与算法代码详解JAVA版
08-26
本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的方式，它为高效地执行各种操作提供了便利。常见的数据结构包括数组、链表、栈、队列、树（如...
【数据结构】堆的创建
zcxyywd的博客
09-12 1549
介绍的堆的概念及它的两种调整方法，堆的创建
堆的创建
sun的博客
08-09 214
二叉堆的定义 堆通常由大根堆和小根堆，大根堆表示父节点大于字节点，小根堆相反 eg:小根堆 1 2 3 4 5 6 7 8 9 [点击并拖拽以移动] 可以看出堆屎一个完全二叉树，我们通常使用数组进行存储，还有一些特点父节点是自己左孩子的二倍，是自己有孩子的二倍加1，可以表示为K=2k和K=2k+1，叶子节点有n/2个。 堆的调整 如果我们要调整一个大根堆，可以将根...
数据结构--关于堆的构造
weixin_53860901的博客
11-14 3065
关于堆的构造一丶相关概念 这一篇博客主要是关于堆的相关问题。 一丶相关概念 因为二叉树有顺序存储和链式存储，所以所谓堆，通常我们可以看做是一个完全二叉树的数组对象。 其具体定义如下： 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最
数据结构堆的创建
Advsance的博客
09-11 708
堆 定义: 一颗完全二叉树，堆中的元素存储到一维数组中，对于任意节点，如果该节点小于其左右孩子，称之为小堆，如果任意一节点值大于其孩子，则称为大堆。（上面最大就是大堆，上面最小就是小堆） 堆的特征：1.堆的顶端一定为最大的，或者最小的 2.如果根节点满足堆，那么他的左子树和右字数也满足堆得性质。（小堆如果不满足，则该节点可以和孩子节点较小的相替换） 3.堆创建的时间复杂度，因为叶子节点比度为2的节...
【数据结构】建堆
m0_52347974的博客
01-23 2412
建堆
堆的构建（C语言版）
折木的博客
03-12 1615
文章目录前言1.认识堆1.1 堆的概念1.2 堆的性质1.3 大根堆和小根堆2. 建堆2.1 设计堆结构2.2 向下调整算法2.3 堆的构建2.4 建堆的时间复杂度 前言 堆是一种重要的数据结构，现实中我们通常把堆（一种二叉树）使用顺序结构的数组来存储。需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆（堆区）是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。 我个人也是在前段时间刚刚结束了堆的学习，不得不说的是堆的难度相较于数据结构前期所学的顺序表、链表、栈、队列等要更上一个台阶。不过在
数据结构动态存储分配-堆分配详解
"堆分配存储表示是数据结构中一种动态管理内存的方式，特别是在程序执行过程中根据需要分配和释放存储空间。这种表示方法常用于顺序表的实现，即字符序列的存储。在C语言中，可以使用`malloc`和`free`函数来动态地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值