堆的概念&实现

于 2024-02-09 17:14:04 发布
阅读量907 收藏 20
点赞数 7
分类专栏： 数据结构初阶 文章标签： c语言 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjiushun/article/details/136075430
版权

前言

本文将详细讲解堆。堆是一种二叉树（一般是完全二叉树）使用顺序结构的数组来存储。
tip：这里我们需要注意区分堆在不同地方的含义，这里的堆是一个数据结构，操作系统虚拟进程地址空间的堆是操作系统中管理内存的一块区域分段。

一、堆的概念及结构

1、堆的概念

如果有一个关键码的集合K，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足堆中某个节点的值总是不大于（或不小于）其父节点的值，则称为大堆（小堆）。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

tip：

  • 堆总是一颗完全二叉树。
  • 大堆：树中所有父亲都大于或等于孩子。
  • 小堆：树中所有父亲都小于或等于孩子。
  • 注意：堆不一定是有序的，因为左右孩子谁大谁小并没有限制。

2、堆的结构

在这里插入图片描述
tip：学习堆我们一定要画图，因为堆在内存中的存储结构是一个数组，但元素之间的逻辑是一颗二叉树，我们很难可以将其想象出来，所以学堆画图很重要！

二、堆的实现

虽然堆分为两类，大根堆和小根堆，但是他们的结构与功能都是类似的，所以这里我们实现一个大堆为例就可以了。

我们先预览堆的结构与所需的接口函数：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//堆——完全二叉树
//虽然堆在内存上是用一段物理地址连续的存储单元依次存储的，但是逻辑关系上是一颗完全二叉树
//堆又分为大根堆和小根堆
//大根堆：树中所有父亲都大于或等于孩子
//小根堆：树中所有父亲都小于或等于孩子
//大根堆和小根堆的实现基本相似，所以这里我们以实现一个大根堆为例

typedef int HPDataType;//重命名堆中数据的类型——》优点：①一改全改；②见名知意
typedef struct Heap
{
	HPDataType* arr;//指向堆区申请的数组
	int size;//存储有效数据个数
	int capacity;//堆的容量空间
}HP;

//堆的初始化——初始化堆的成员变量
void HeapInit(HP* php);

//堆的销毁——动态申请的空间，自己要记得销毁，否则可能造成内存泄漏
void HeapDestroy(HP* php);

//交换
void Swap(HPDataType* e1, HPDataType* e2);

//堆的向上调整
void AdjustUp(HPDataType* arr, int child);

//堆的插入
void HeapPush(HP* php, HPDataType x);

//打印堆数组
void HeapPrint(HP* php);

//判断堆是否为空
bool HeapIsEmpty(HP* php);

//堆的向下调整
void AdjustDown(HPDataType* arr, int n, int parent);

//堆的删除
void HeapPop(HP* php);

//获取堆顶元素
HPDataType HeapTop(HP* php);

//获取堆的有效元素个数
int HeapSize(HP* php);

1、堆的结构

堆由三个成员变量组成，分别是arr指针指向动态申请的数组、size存储堆的有效数据个数、capacity存储堆的容量，所以堆是一个复杂结构，我们将其定义为结构体。

typedef int HPDataType;//重命名堆中数据的类型——》优点：①一改全改；②见名知意
typedef struct Heap
{
	HPDataType* arr;//指向堆区申请的数组
	int size;//存储有效数据个数
	int capacity;//堆的容量空间
}HP;

tip：

  • 建议将堆中存储的数据的类型typedef，typedef 一可以方便我们更改堆的类型，二见名知意。

2、堆的初始化

堆的初始化模块功能：初始化堆对象的三个成员变量

//堆的初始化——初始化堆的成员变量
void HeapInit(HP* php)
{
	//断言指针的有效性，php不可能为空
	assert(php);
	//初始化堆的成员
	php->arr = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (NULL == php->arr)
	{
		//扩容失败
		perror("HeapInit::malloc");
		return;
	}
	php->size = 0;
	php->capacity = 4;
}

3、堆的销毁

堆的销毁模块功能：清理堆对象使用的资源，并销毁堆对象中动态申请的资源。

//堆的销毁——动态申请的空间，自己要记得销毁，否则可能造成内存泄漏
void HeapDestroy(HP* php)
{
	assert(php);
	//释放堆对象申请的动态空间
	free(php->arr);
	//free之后php->arr仍指向原来的空间，可能造成非法访问或多次释放，建议置为空
	php->arr = NULL;
	php->size = 0;
	php->capacity = 0;
}

4、堆的插入(重点)

堆的插入模块功能：先在数组尾插入数据，数据再向上调整找到自己在大堆中的位置。

问题1： 堆插入为什么只有一种？

因为堆要满足大根堆或小根堆的性质，头插和任意位置插入会改变堆原本的结构，而尾插不会改变堆原本的结构。

问题2： 已知有一个数组，它是按照大根堆的性质存储的。现在我们在数组尾插入一个数据80，仍想让数组按照大根堆存储，该怎么实现？

  1. 使用向上调整算法实现。
  2. 向上调整算法的思想：在这里插入图片描述
    • 将目标节点（孩子结点）与其父节点比较。
    • 如果目标节点大于其父节点，交换两个节点的值，并继续向上比较。
    • 结束向上比较的条件：①如果目标节点小于其父节点，则停止向上比较；②最坏的情况是向上比较到根才结束。
  3. 因为其过程是不断的向上比较，所以将其叫做向上调整算法。

    tip：向上调整的前提是除了目标位置，前面数据构成大堆/小堆。

（1）交换两个数据

因为在堆中许多地方都会交换两个数据，所以我们将其模块化。

//交换——有多个模块需要交换，所以将其模块化
void Swap(HPDataType* e1, HPDataType* e2)
{
	HPDataType temp = *e1;
	*e1 = *e2;
	*e2 = temp;
}

tip：

  • 注意：值传递不会改变形参的改变不会改变实参。

（2）向上调整

注意：向上调整的前提是除了目标位置，前面数据构成大堆/小堆。

//堆的向上调整
void AdjustUp(HPDataType* arr, int child)
{
	//存储父亲的下标
	int parent = (child - 1) / 2;
	//大堆向上调整：当孩子大于父亲时，孩子与父亲交换
	//向上调整的结束条件：
	//①最坏情况：向上到根才结束，即child = 0(parent<0)。但注意不能用parent < 0作为结束，因为parent = (child - 1) / 2不可能小于0.
	//②特殊情况：当孩子不大于父亲时结束。
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			//交换
			Swap(&arr[child], &arr[parent]);
			//继续向上调整
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//跳出循环
			break;
		}
	}
}

tip：

  • 最坏情况是到根结束，注意不能用parent < 0来判断，因为parent = （child - 1）/ 2不可能小于0。
  • 小根堆的向上调整与大根堆类似，只需将if中的arr[child] > arr[parent]改成arr[child] < arr[parent]即可。

（3）堆的插入

//堆的插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//1、向堆插入数据，要先判断是否扩容
	if (php->size == php->capacity)
	{
		//扩容
		//realloc可能扩容失败，所以先使用一个临时变量保存realloc的返回值
		HPDataType* temp = (HPDataType*)realloc(php->arr, sizeof(HPDataType) * php->capacity * 2);
		//判断是否扩容成功
		if (temp != NULL)
		{
			//扩容成功，仍然使用php->arr指向申请的空间，并将temp置为空
			php->arr = temp;
			temp = NULL;
			//注意别忘记更新容量
			php->capacity *= 2;
		}
		else
		{
			perror("realloc");
			return;
		}
	}
	//2、堆的插入——先在数组尾插入数据，再向上调整
	//①数组尾插——不需要挪动，时间复杂度O(1)
	php->arr[php->size] = x;
	php->size++;
	//②向上调整
	AdjustUp(php->arr, php->size - 1);
}

tip：

  • 注意我们插入数据之前，要检查是否需要扩容。

5、堆的判空

堆的判空模块功能：如果堆为空，则返回真；反之，返回假。

//判断堆是否为空
bool HeapIsEmpty(HP* php)
{
	assert(php);
	//当堆中有效个数为0时，堆为空
	return 0 == php->size;
}

tip：

  • 判断一个变量与一个常量是否相等时，建议变量做右操作数，提高代码的健壮性。

6、堆的删除(重点)

堆的删除模块功能：删除堆顶的元素。

问题1： 堆的删除为什么只能删除堆顶元素？

因为堆的性质，堆顶元素的值最大或最小。

所以删除堆顶元素才有意义，删除掉最大的之后我们可以继续选出第二大的。

问题2： 我们直接删除堆顶？

我们不会直接删除堆顶元素，因为直接删除堆顶元素有两大问题：

  • 数组头删，需要挪动数据，时间复杂度为O(N)，效率低。
  • 父子兄弟关系全乱了。在这里插入图片描述

问题3： 怎样删除堆顶？

思路：

  1. 交换：把堆顶元素与最后一个元素交换
  2. 删除堆顶：数组尾删，直接size–即可
  3. 向下调整：运用向下调整算法，确保堆的结构。

问题4： 怎样向下调整？

在这里插入图片描述
思路：

  1. 通过假设法选出左右孩子较大的那个孩子结点
  2. 将较大的那个孩子结点与父节点比较，如果比父节点大，则交换
  3. 继续向下比较，直到比父节点小才停止，最坏的情况是，向下比较到叶子才停止。

    tip：向下调整的前提是左右子树都是大堆/小堆。

（1）向下调整

注意：向下调整的前提是左右子树都是大堆/小堆。

//堆的向下调整
void AdjustDown(HPDataType* arr, int n, int parent)
{
	//假设法：定义一个变量存储较大孩子的下标，先假设左孩子大，再通过if确定假设是否成立。
	int child = parent * 2 + 1;
	//大堆向下调整：当父亲小于较大的孩子，孩子与父亲交换
	//向下结束的条件：
	//①最坏情况： 向下到叶子结束，即child(parent * 2 + 1) > n。
	//②特殊情况：当孩子不小于父亲时结束。
	while (child < n)
	{
		//if确定假设是否成立
		//注意：要先判断child + 1是否为堆有效数据
		if (child + 1 < n && arr[child] < arr[child + 1])
		{
			++child;
		}
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//继续向下调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

tip：

  • 比较左右孩子的时候，需要先判断右孩子是否为堆的有效数据，当child(parent * 2 + 1) > n，没有右孩子。
  • 小根堆的向下调整与大根堆类似，只需将if中的arr[child] > arr[parent]改成arr[child] < arr[parent]即可。

（2）堆的删除

//堆的删除
void HeapPop(HP* php)
{
	assert(php);
	//删除堆不能为空
	assert(!HeapIsEmpty(php));
	//堆只有删除堆顶元素才有意义
	//问题：是直接删吗？
	//答案是：不是，直接删，有两个问题——①效率低，挪动数据时间复杂度O(N)；②堆的父子兄弟关系全乱了
	//①交换堆顶与堆尾
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//②数组尾删
	php->size--;
	//③向下调整
	AdjustDown(php->arr, php->size, 0);
}

tip：

  • 在删除数据之前，需要判断堆是否为空。
  • 堆删除的思路口诀：一交换二删除三向下调整。

7、获取堆顶元素

//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	//断言堆不为空
	assert(!HeapIsEmpty(php));
	return php->arr[0];
}

tip：

  • 为了程序的健壮性，在获取之前断言堆不为空。
  • 获取堆顶元素，直接返回数组下标为0的元素即可

8、获取堆的有效数据个数

//获取堆的有效元素个数
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

tip：

  • 直接返回size即可。

9、堆的打印

//打印堆数组
void HeapPrint(HP* php)
{
	assert(php);
	int i = 0;
	for (i = 0; i < php->size; ++i)
	{
		printf("%d ", php->arr[i]);
	}
	printf("\n");
}

tip：

  • 堆在内存中是连续存储的其本质就是数组，所以使用for循环就打印了。

三、总代码

1、接口声明模块

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//堆——完全二叉树
//虽然堆在内存上是用一段物理地址连续的存储单元依次存储的，但是逻辑关系上是一颗完全二叉树
//堆又分为大根堆和小根堆
//大根堆：树中所有父亲都大于或等于孩子
//小根堆：树中所有父亲都小于或等于孩子
//大根堆和小根堆的实现基本相似，所以这里我们以实现一个大根堆为例

typedef int HPDataType;//重命名堆中数据的类型——》优点：①一改全改；②见名知意
typedef struct Heap
{
	HPDataType* arr;//指向堆区申请的数组
	int size;//存储有效数据个数
	int capacity;//堆的容量空间
}HP;

//堆的初始化——初始化堆的成员变量
void HeapInit(HP* php);

//堆的销毁——动态申请的空间，自己要记得销毁，否则可能造成内存泄漏
void HeapDestroy(HP* php);

//交换
void Swap(HPDataType* e1, HPDataType* e2);

//堆的向上调整
void AdjustUp(HPDataType* arr, int child);

//堆的插入
void HeapPush(HP* php, HPDataType x);

//打印堆数组
void HeapPrint(HP* php);

//判断堆是否为空
bool HeapIsEmpty(HP* php);

//堆的向下调整
void AdjustDown(HPDataType* arr, int n, int parent);

//堆的删除
void HeapPop(HP* php);

//获取堆顶元素
HPDataType HeapTop(HP* php);

//获取堆的有效元素个数
int HeapSize(HP* php);

2、接口实现模块

#include"Heap.h"

//堆的初始化——初始化堆的成员变量
void HeapInit(HP* php)
{
	//断言指针的有效性，php不可能为空
	assert(php);
	//初始化堆的成员
	php->arr = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (NULL == php->arr)
	{
		//扩容失败
		perror("HeapInit::malloc");
		return;
	}
	php->size = 0;
	php->capacity = 4;
}

//堆的销毁——动态申请的空间，自己要记得销毁，否则可能造成内存泄漏
void HeapDestroy(HP* php)
{
	assert(php);
	//释放堆对象申请的动态空间
	free(php->arr);
	//free之后php->arr仍指向原来的空间，可能造成非法访问或多次释放，建议置为空
	php->arr = NULL;
	php->size = 0;
	php->capacity = 0;
}

//交换——有多个模块需要交换，所以将其模块化
void Swap(HPDataType* e1, HPDataType* e2)
{
	HPDataType temp = *e1;
	*e1 = *e2;
	*e2 = temp;
}

//堆的向上调整
void AdjustUp(HPDataType* arr, int child)
{
	//存储父亲的下标
	int parent = (child - 1) / 2;
	//大堆向上调整：当孩子大于父亲时，孩子与父亲交换
	//向上调整的结束条件：
	//①最坏情况：向上到根才结束，即child = 0(parent<0)。但注意不能用parent < 0作为结束，因为parent = (child - 1) / 2不可能小于0.
	//②特殊情况：当孩子不大于父亲时结束。
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			//交换
			Swap(&arr[child], &arr[parent]);
			//继续向上调整
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//跳出循环
			break;
		}
	}
}

//堆的插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//1、向堆插入数据，要先判断是否扩容
	if (php->size == php->capacity)
	{
		//扩容
		//realloc可能扩容失败，所以先使用一个临时变量保存realloc的返回值
		HPDataType* temp = (HPDataType*)realloc(php->arr, sizeof(HPDataType) * php->capacity * 2);
		//判断是否扩容成功
		if (temp != NULL)
		{
			//扩容成功，仍然使用php->arr指向申请的空间，并将temp置为空
			php->arr = temp;
			temp = NULL;
			//注意别忘记更新容量
			php->capacity *= 2;
		}
		else
		{
			perror("realloc");
			return;
		}
	}
	//2、堆的插入——先在数组尾插入数据，再向上调整
	//①数组尾插——不需要挪动，时间复杂度O(1)
	php->arr[php->size] = x;
	php->size++;
	//②向上调整
	AdjustUp(php->arr, php->size - 1);
}

//打印堆数组
void HeapPrint(HP* php)
{
	assert(php);
	int i = 0;
	for (i = 0; i < php->size; ++i)
	{
		printf("%d ", php->arr[i]);
	}
	printf("\n");
}

//判断堆是否为空
bool HeapIsEmpty(HP* php)
{
	assert(php);
	//当堆中有效个数为0时，堆为空
	return 0 == php->size;
}

//堆的向下调整
void AdjustDown(HPDataType* arr, int n, int parent)
{
	//假设法：定义一个变量存储较大孩子的下标，先假设左孩子大，再通过if确定假设是否成立。
	int child = parent * 2 + 1;
	//大堆向下调整：当父亲小于较大的孩子，孩子与父亲交换
	//向下结束的条件：
	//①最坏情况： 向下到叶子结束，即child(parent * 2 + 1) > n。
	//②特殊情况：当孩子不小于父亲时结束。
	while (child < n)
	{
		//if确定假设是否成立
		//注意：要先判断child + 1是否为堆有效数据
		if (child + 1 < n && arr[child] < arr[child + 1])
		{
			++child;
		}
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//继续向下调整
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆的删除
void HeapPop(HP* php)
{
	assert(php);
	//删除堆不能为空
	assert(!HeapIsEmpty(php));
	//堆只有删除堆顶元素才有意义
	//问题：是直接删吗？
	//答案是：不是，直接删，有两个问题——①效率低，挪动数据时间复杂度O(N)；②堆的父子兄弟关系全乱了
	//①交换堆顶与堆尾
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//②数组尾删
	php->size--;
	//③向下调整
	AdjustDown(php->arr, php->size, 0);
}

//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	//断言堆不为空
	assert(!HeapIsEmpty(php));
	return php->arr[0];
}

//获取堆的有效元素个数
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

3、功能测试模块

#include"Heap.h"

int main()
{
	//定义堆变量
	HP hp;
	//初始化
	HeapInit(&hp);
	//插入数据
	HeapPush(&hp, 6);
	HeapPush(&hp, 16);
	HeapPush(&hp, 36);
	HeapPush(&hp, 56);
	HeapPush(&hp, -1);
	HeapPush(&hp, 5);
	HeapPush(&hp, -16);
	HeapPush(&hp, 35);
	HeapPush(&hp, 19);
	HeapPush(&hp, 9);
	HeapPush(&hp, 6);
	HeapPush(&hp, 18);
	HeapPrint(&hp);
	//找出前k个大的数
	int k = 0;
	scanf("%d", &k);
	while (!HeapIsEmpty(&hp) && k--)
	{
		printf("%d ", HeapTop(&hp));
		//删除
		HeapPop(&hp);
	}
	printf("\n");
	HeapDestroy(&hp);
	return 0;
}

运行结果：

在这里插入图片描述

从前慢，现在也慢
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现堆排序的实例讲解
12-20
堆是一种完全二叉树（是除了最后一层，其它每一层都被完全填充，保持所有节点都向左对齐），首先需要知道概念：最大堆问题，最大堆就是根节点比子节点值都大，并且所有根节点都满足，那么称它为最大堆。反之最小堆。...
堆排序——Java与Go实现
01-20
概念分析 堆排序是使用堆这种数据结构进行排序的方法。（好像是废话） 思路分析 首先，我们将待排序的数组看作一个完全二叉树 将此二叉树转成大顶堆或者小顶堆 将堆顶元素与堆的最后一个元素互换，之后丢弃最后一个...
数据结构——【堆】详解
Lucky_mzc的博客
03-08 6324
一. 堆🌲 1. 堆的概念 堆（heap）：一种有特殊用途的数据结构——用来在一组变化频繁（发生增删查改的频率较高）的数据集中查找最值。 堆在物理层面上，表现为一组连续的数组区间：long[] array ；将整个数组看作是堆。 堆在逻辑结构上，一般被视为是一颗完全二叉树。 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆；反之，则是小堆，或者小根堆，或者最小堆。当一个堆为大堆时，它的每一棵子树都是大堆。 2. 堆的存储方式 从堆的概念可知，堆是一棵完全二叉树，
【数据结构】堆的概念 | 从零开始实现数组堆
⚡ 柠檬叶子团队
11-27 2270
我们之前似乎确凿在C语言教学里讲过堆，但是那是操作系统中的堆，我们今天将要讲的堆是数据结构里的堆。数据结构中也有栈和堆，它跟操作系统对内存划分中的栈和堆没有关系。我横竖卷不动其他人，于是就打算再更亿篇博客罢。
什么是堆
每天叫醒自己的不是闹铃 是娟 是梦 是理想。
05-14 7621
堆是一种特殊的树，只要满足下面两个条件，它就是一个堆： （1）堆是一颗完全二叉树； （2）堆中某个节点的值总是不大于（或不小于）其父节点的值。 其中，我们把根节点最大的堆叫做大顶堆，根节点最小的堆叫做小顶堆。 堆详解 满二叉树 满二叉树是指所有层都达到最大节点数的二叉树。比如，下面这颗树： 完全二叉树 完全二叉树是指除了最后一层其它层都达到最大节点数，且最后一层节点都靠左排列。比如，下面这颗树： 可见，其实满二叉树是一种特殊的完全二叉树。 那么，使用什么结构存储完全二叉树最节省空
堆的相关概念
LCW0102的博客
01-11 1355
一、堆的概念 1、堆在逻辑上是一颗完全二叉树（类似于一颗满二叉树只缺了右下角） 2、堆的实现利用的是数组，我们通常会利用动态数组来存放元素，这样可以快速拓容也不会很浪费空间，我们是将这颗完全二叉树用层序遍历的方式储存在数组里的 3、堆有两种分别是大根堆和小根堆 二、大根堆     大根堆就是整个完全二叉树，任意一个根节点的值都比左右子树的值大。     这就是一个大根堆，所有根节点的值永远比左右子树的大，那么就可以看出，整棵树的根节点，他的值是整个堆中最大的。同时我们也发现没有直接父子关系的节点他们的值没
数据结构总结一——堆
weixin_45738899的博客
12-09 1084
数据结构总结——堆1.堆的基本概念2.代码讲解1.堆的构建 1.堆的基本概念 摘自百度百科： 堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。 1.堆中某个结点的值总是不大于(最大堆)或不小于(最小堆)其父结点的值； 2.堆总是一棵完全二叉树。 从结构上看，堆是一棵完全二叉树。但它实际上是以完全二叉树的数组映射形式储存在数组中的。树中每个结点的值总是不大于(最大堆)或不小于(最小堆)其父结点的值。所以堆顶元素总是所有元素中的最大值或最小值
交换机级联和堆叠的基本概念及区别-综合文档
05-22
[摘要] 基本概念的理解 级联是共享，堆叠是独享。 堆叠是背板之间的连接，通过交换机的背板把几台交换机做成一个整体连接起来级联是通过交换机的某个端口与其它交换机相连的（也就是端口的连接） 虽然级联和堆叠都...
C语言实现堆排序的简单实例
01-20
本文通过一个C语言实现堆排序的简单实例，帮助大家抛开复杂的概念，更好的理解堆排序。 实例代码如下： void FindMaxInHeap(int arr[], const int size) { for (int j = size - 1; j > 0; --j) { int parent = j ...
Python堆排序原理与实现方法详解
09-20
主要介绍了Python堆排序原理与实现方法,结合实例形式详细分析了Python堆排序的概念、原理、实现方法及相关操作注意事项,需要的朋友可以参考下
数据结构基础——堆的概念、结构及应用
m0_60502858的博客
11-07 3443
数据结构基础——堆的概念、结构及应用 目录 堆的概念 堆这种数据结构的代码实现 堆在排序算法上的应用 1.堆的概念 堆就是以二叉树的顺序存储方式来存储元素，同时又要满足父亲结点存储数据都要大于儿子结点存储数据（也可以是父亲结点数据都要小于儿子结点数据）的一种数据结构。堆只有两种即大堆和小堆，大堆就是父亲结点数据大于儿子结点数据，小堆则反之。 堆的性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。 用图画展示就如下图所示： 2.堆这种数据结构的代码实现 了解了堆的概念之后
数据结构学习记录——什么是堆（优先队列、堆的概念、最大堆最小堆、优先队列的完全二叉树表示、堆的特性、堆的抽象数据类型描述）
li13437542099的博客
04-30 1689
数据结构学习记录——什么是堆（优先队列、堆的概念、最大堆最小堆、优先队列的完全二叉树表示、堆的特性、堆的抽象数据类型描述） 给出的这四个方案中，总有存在不足。要么是提高了插入操作的效率，删除操作的效率十分低；要么是提高了删除操作的效率，而插入操作的效率十分低。二叉树。
堆的概念和结构以及堆排序
wutongguo的博客
02-22 1081
堆的概念和堆排序的时间复杂度的讲解
堆的概念及基本操作实现
热门推荐
多反思，多回顾，要坚持。
03-25 1万+
1.堆的基本概念： 严格来讲，堆有不同的种类，但是我们在算法学习中，主要用的还是二叉堆，而二叉堆有最大堆和最小堆之分。 最大（最小）堆是一棵每一个节点的键值都不小于（大于）其孩子（如果存在）的键值的树。大顶堆是一棵完全二叉树，同时也是一棵最大树。小顶堆是一棵完全完全二叉树，同时也是一棵最小树。 需要注意的问题是：堆中的任一子树也还是堆，即大顶堆的子树也都是大顶堆，小顶堆同样。
浅浅理解一下堆
qq_59539549的博客
03-05 3695
一、堆的定义及本质 堆在Java中是以优先级队列来表现的（PrityQueue），不传入外部比较器则以小堆来实现（取出最小值） 前提：优先级队列中的元素具备比较能力（1.元素类型本身是可以比较的 2.通过构造方法传入一个外部比较器） 堆的作用：常用来在频繁变动的数据集中找出最值 堆的本质：逻辑上是完全二叉树，本质上是数组 堆的定义： 堆总是满足下列性质： 1.堆中某个节点的值总是不大于或不小于其父节点的值； 2、堆总是一棵完全二叉树。 将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆
堆的概念
weixin_43250623的博客
04-20 220
堆的概念 堆(heap)又被为优先队列(priority queue)。尽管名为优先队列，但堆并不是队列。回忆一下，在队列中，我们可以进行的限定操作是dequeue和enqueue。dequeue是按照进入队列的先后顺序来取出元素。而在堆中，我们不是按照元素进入队列的先后顺序取出元素的，而是按照元素的优先级取出元素 堆是一种基本的数据结构。在一个二叉堆的数组中，每一个元素都要保证大于等于另...
堆的概念及用C语言的实现
m0_73451678的博客
11-22 435
当堆Push数据（堆尾插数据）时，为了维持堆，需要和父节点比较，大小顺序不一致就需要调整，调整一次后还要再跟父节点比较，顺序不一致继续调，此过程封装一个Adjustup函数。 当堆Pop数据（出堆顶数据）时，为了不影响树的结构，此时引入一个方法：将堆顶和堆底数据互换，删除堆底数据，但此时堆顶的数据是维持不了堆的，需要调整至下一层，也有可能这一层也维持不了堆，还需要继续向下调整，直至最底。调整的过程封装一个Adjustdown函数。
python堆和栈的概念
最新发布
08-16
在Python中，堆(heap)和栈(stack)是两种不同的概念。 堆是一种内存管理方式，在程序内存布局场景下表示动态分配的内存空间。在Python中，我们可以使用heapq模块来实现优先级队列。优先级队列是一种特殊的队列，其中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值