数据结构——堆

于 2022-03-26 20:47:42 发布
阅读量1k 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63020222/article/details/123762322
版权

一、概念

1.定义

堆：堆在逻辑结构上可以看作一棵完全二叉树，并且任意结点比它的左、右孩子大（小），称为大（小）堆，或者大（小）根堆；根节点称为堆顶；每条路径一定是升序或者降序。

逻辑结构与存储结构：

2.堆的实现思路

2.1堆的创建

在给定的一个数组，在逻辑上看作一棵完全二叉树，我们可以通过从根结点开始向下调整算法把它调整成为一个堆，但利用向下调整算法有一个前提，那就是左右子树必须是一个堆，才能利用此算法进行调整。

结合二叉树的性质，我们可以通过从二叉树的倒数第一个非叶子结点的子树开始调整，一直调整到根结点的树，这样就可以把完全二叉树调整为一个堆了

2.2堆的插入

结合堆的创建与调整思想，堆的插入可以通过插入到数组的末尾，即完全二叉树的末尾，然后采用向上调整算法，直至完全二叉树满足堆的定义。

2.3堆的删除

删除堆是删除堆顶的数据，但我们若直接删除堆顶，那么堆就缺失了堆顶，完全二叉树没有了根结点，即该结构不再满足堆的定义。

正确的删除方法是，将堆顶元素与最后一个元素进行对换，然后删除最后一个元素，这样就完成了堆的删除操作，但是对换之后，堆顶可能不再满足堆的特性，此时还需要对堆顶进行向下调整，直至恢复成堆。

二、结构体定义

typedef int HPDataType;
typedef int (*PFUNC)(HPDataType left, HPDataType right);
typedef struct Heap
{
	HPDataType* array;
	int size;//有效元素个数
	int capacity;//容量
	PFUNC pCompare;//大根堆or小根堆 回调函数
}Heap;

这里为了方便我们建立不同的堆，在结构体中增加了一个回调函数，具体实现原理在后续代码中。

三、接口实现

void HeapCreate(Heap* hp, HPDataType* array, int length, PFUNC pCompare);// 堆的构建
int Min(HPDataType right, HPDataType left);//创小根堆回调函数
int Max(HPDataType right, HPDataType left);//创大根堆回调函数
void AdjustDown_Heap(Heap* hp, int parent);//堆调整函数
void Swap(HPDataType* parent, HPDataType* child);//将结点与较大或较小的孩子进行交换
void HeapCheckCapacity(Heap* hp); //判满 & 扩容
int HeapEmpty(Heap* hp);// 堆的判空
void HeapPush(Heap* hp, HPDataType x);// 堆的插入
void HeapErase(Heap* hp);// 堆的删除
HPDataType HeapTop(Heap* hp);// 取堆顶的数据
int HeapSize(Heap* hp);// 堆的数据个数
void HeapDestroy(Heap* hp);// 堆的销毁
void print_Heap(Heap* hp);//打印函数
void Test_Heap();//测试函数

1.堆的构建

void HeapCreate(Heap* hp, HPDataType* array, int length, PFUNC pCompare) {// 堆的构建
	assert(hp);
	hp->array = (HPDataType*)malloc(sizeof(HPDataType) * length);
	if (hp->array == NULL) {//申请失败
		assert(0);
		return;
	}
	hp->capacity = length;
	memcpy(hp->array, array, sizeof(HPDataType) * length);//将数组内元素拷贝到堆中
	hp->size = length;
	hp->pCompare = pCompare;
	for (int root = ((hp->size - 1) - 1) / 2; root >= 0; root--) {//对堆进行调整
		AdjustDown_Heap(hp, root);//堆调整函数
	}
}

结合完全二叉树的特性，最后一个结点的双亲即倒数第一个非叶子结点；结点n的双亲结点等于(n-1)/2，因为size为堆的大小，所以其最后一个叶子结点的下标为size-1，所以代码中有两个减一操作。

然后通过向下调整算法从倒数第一个非叶子结点往回调整。

1.1向下调整函数

void AdjustDown_Heap(Heap* hp,int parent) {//堆调整函数
	int child = parent * 2 + 1;//parent可能只有左没有右，所以标记左孩子
	int size = hp->size;
	while (child < size) {
		if (child + 1 < size && hp->pCompare(hp->array[child + 1], hp->array[child])) {//找parent较小的孩子
			child += 1;
		}
		//检测当前结点即孩子是否满足堆的特性
		if (hp->pCompare(hp->array[child], hp->array[parent])) {//较小（较大）孩子比结点小（大），交换两个结点
			Swap(&hp->array[parent], &hp->array[child]);
			parent = child;//交换后子树可能不满足小（大）堆，继续往下标记判断
			child = parent * 2 + 1;
		}
		else {//当前结点满足堆特性，不需要继续向下调整
			return;
		}
	}
}

因为，双亲结点可能没有有孩子，所以我们标记双亲结点的左孩子，通过找出并标记较小（创小堆Min）或较大（创大堆Max）的孩子，再与根结点进行比较，判断当前结点是否需要调整。

2.堆的判满与扩容

void HeapCheckCapacity(Heap* hp) {//判满&扩容
	assert(hp);
	if (hp->size == hp->capacity) {
		int newCapacity = hp->capacity * 2;//扩大为原容量两倍
		HPDataType* temp = (HPDataType*)malloc(sizeof(HPDataType) * newCapacity);
		if (temp == NULL) {//申请失败
			assert(0);
			return;
		}
		memcpy(temp, hp->array, sizeof(HPDataType) * hp->size);//将数据拷贝到新空间中
		free(hp->array);
		hp->array = temp;
		hp->capacity = newCapacity;
	}
}

3.堆的插入

void HeapPush(Heap* hp, HPDataType x) {// 堆的插入
	assert(hp);
	HeapCheckCapacity(hp);//判满&自动扩容
	hp->array[hp->size] = x;//插入到堆的末尾
	hp->size++;
	AdjustUp_Heap(hp, hp->size - 1);//插入后需向上调整
}

将元素插入到末尾，采用向上调整算法进行调整至堆。

3.1向上调整函数

void AdjustUp_Heap(Heap* hp, int child) {//向上调整函数
	int parent = (child - 1) / 2;//标记该结点的双亲结点
	while (child) {
		if (hp->pCompare(hp->array[child], hp->array[parent])) {//该结点比双亲结点小（大）
			Swap(&hp->array[parent], &hp->array[child]);//较小的往上交换
			child = parent;//标记双亲结点为新的child结点，继续向上调整
			parent = (child - 1) / 2;
		}
		else {//该节点满足堆的特性，不需要进行调整
			return;
		}
	}
}

原理与向下调整算法相同。

4.堆的判空

int HeapEmpty(Heap* hp) {// 堆的判空
	assert(hp);
	return hp->size == 0;//空返回1，非空返回0
}

5.堆的删除

void HeapErase(Heap* hp) {// 堆的删除(删除堆顶）
	assert(hp);
	if (HeapEmpty(hp)) {//判空
		return;
	}
	Swap(&hp->array[0], &hp->array[hp->size - 1]);//先交换堆顶与堆尾元素
	hp->size--;//堆内有效元素个数减一
	AdjustDown_Heap(hp, 0);//堆顶向下调整
}

（1）交换堆顶与末尾元素；（2）删除末尾元素；（3）堆根结点进行向下调整。

6.取堆顶元素

HPDataType HeapTop(Heap* hp) {// 取堆顶的数据
	assert(hp);
	return hp->array[0];
}

7.返回堆有效元素个数

int HeapSize(Heap* hp) {// 堆的数据个数
	assert(hp);
	return hp->size;
}

8.堆销毁

void HeapDestroy(Heap* hp) {// 堆的销毁
	assert(hp);
	if (hp->array) {
		free(hp->array);
		hp->array = NULL;
		hp->capacity = 0;
		hp->size = 0;
	}
}

（1）释放数组空间；（2）置零容量与有效元素个数。

四、接口测试

1.测试函数

void Test_Heap() {
	int array[] = { 49, 27, 37, 65, 28, 34, 25, 15, 18, 19 };
	Heap hp;
	HeapCreate(&hp, array, sizeof(array) / sizeof(array[0]), Max);//创建小根堆
	print_Heap(&hp);

	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	HeapPush(&hp, 10);//插入10
	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	HeapErase(&hp);
	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	print_Heap(&hp);
	HeapDestroy(&hp);//销毁
}

2.测试结果

2.1建大堆：

 2.2建小堆（实参Max改为Min)

 五、完整代码

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<string.h>

typedef int HPDataType;
typedef int (*PFUNC)(HPDataType left, HPDataType right);
typedef struct Heap
{
	HPDataType* array;
	int size;//有效元素个数
	int capacity;//容量
	PFUNC pCompare;//大根堆or小根堆 回调函数
}Heap;

void HeapCreate(Heap* hp, HPDataType* array, int length, PFUNC pCompare);// 堆的构建
int Min(HPDataType right, HPDataType left);//创小根堆回调函数
int Max(HPDataType right, HPDataType left);//创大根堆回调函数
void AdjustDown_Heap(Heap* hp, int parent);//堆调整函数
void Swap(HPDataType* parent, HPDataType* child);//将结点与较大或较小的孩子进行交换
void HeapCheckCapacity(Heap* hp); //判满 & 扩容
int HeapEmpty(Heap* hp);// 堆的判空
void HeapPush(Heap* hp, HPDataType x);// 堆的插入
void HeapErase(Heap* hp);// 堆的删除
HPDataType HeapTop(Heap* hp);// 取堆顶的数据
int HeapSize(Heap* hp);// 堆的数据个数
void HeapDestroy(Heap* hp);// 堆的销毁
void print_Heap(Heap* hp);//打印函数
void Test_Heap();//测试函数

int main() {
	Test_Heap();
	return 0;
}

void print_Heap(Heap* hp) {//打印函数
	printf("-----------------------------\n");
	for (int i = 0; i < hp->size; i++) {
		printf("%d ", hp->array[i]);
	}
	printf("\n-----------------------------\n");
}

void Test_Heap() {
	int array[] = { 49, 27, 37, 65, 28, 34, 25, 15, 18, 19 };
	Heap hp;
	HeapCreate(&hp, array, sizeof(array) / sizeof(array[0]), Min);//创建小根堆
	print_Heap(&hp);

	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	HeapPush(&hp, 10);//插入10
	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	HeapErase(&hp);
	printf("top = %d\n", HeapTop(&hp));
	printf("size = %d\n", HeapSize(&hp));

	print_Heap(&hp);
	HeapDestroy(&hp);//销毁
}

void Swap(HPDataType* parent, HPDataType* child) {//将结点与较大或较小的孩子进行交换
	HPDataType temp = *parent;
	*parent = *child;
	*child = temp;
}

int Min(HPDataType right, HPDataType left) {//创小根堆回调函数
	return right < left;
}

int Max(HPDataType right, HPDataType left) {//创大根堆回调函数
	return right > left;
}

void HeapCreate(Heap* hp, HPDataType* array, int length, PFUNC pCompare) {// 堆的构建
	assert(hp);
	hp->array = (HPDataType*)malloc(sizeof(HPDataType) * length);
	if (hp->array == NULL) {//申请失败
		assert(0);
		return;
	}
	hp->capacity = length;
	memcpy(hp->array, array, sizeof(HPDataType) * length);//将数组内元素拷贝到堆中
	hp->size = length;
	hp->pCompare = pCompare;
	for (int root = ((hp->size - 1) - 1) / 2; root >= 0; root--) {//对堆进行调整
		AdjustDown_Heap(hp, root);//堆调整函数
	}
}

void AdjustDown_Heap(Heap* hp,int parent) {//堆向下调整函数
	int child = parent * 2 + 1;//parent可能只有左没有右，所以标记左孩子
	int size = hp->size;
	while (child < size) {
		if (child + 1 < size && hp->pCompare(hp->array[child + 1], hp->array[child])) {//找parent较小的孩子
			child += 1;
		}
		//检测当前结点即孩子是否满足堆的特性
		if (hp->pCompare(hp->array[child], hp->array[parent])) {//较小（较大）孩子比结点小（大），交换两个结点
			Swap(&hp->array[parent], &hp->array[child]);
			parent = child;//交换后子树可能不满足小（大）堆，继续往下标记判断
			child = parent * 2 + 1;
		}
		else {//当前结点满足堆特性，不需要继续向下调整
			return;
		}
	}
}

void AdjustUp_Heap(Heap* hp, int child) {//向上调整函数
	int parent = (child - 1) / 2;//标记该结点的双亲结点
	while (child) {
		if (hp->pCompare(hp->array[child], hp->array[parent])) {//该结点比双亲结点小（大）
			Swap(&hp->array[parent], &hp->array[child]);//较小的往上交换
			child = parent;//标记双亲结点为新的child结点，继续向上调整
			parent = (child - 1) / 2;
		}
		else {//该节点满足堆的特性，不需要进行调整
			return;
		}
	}
}

void HeapCheckCapacity(Heap* hp) {//判满&扩容
	assert(hp);
	if (hp->size == hp->capacity) {
		int newCapacity = hp->capacity * 2;//扩大为原容量两倍
		HPDataType* temp = (HPDataType*)malloc(sizeof(HPDataType) * newCapacity);
		if (temp == NULL) {//申请失败
			assert(0);
			return;
		}
		memcpy(temp, hp->array, sizeof(HPDataType) * hp->size);//将数据拷贝到新空间中
		free(hp->array);
		hp->array = temp;
		hp->capacity = newCapacity;
	}
}

void HeapPush(Heap* hp, HPDataType x) {// 堆的插入
	assert(hp);
	HeapCheckCapacity(hp);//判满&自动扩容
	hp->array[hp->size] = x;//插入到堆的末尾
	hp->size++;
	AdjustUp_Heap(hp, hp->size - 1);//插入后需向上调整
}

void HeapErase(Heap* hp) {// 堆的删除(删除堆顶）
	assert(hp);
	if (HeapEmpty(hp)) {//判空
		return;
	}
	Swap(&hp->array[0], &hp->array[hp->size - 1]);//先交换堆顶与堆尾元素
	hp->size--;//堆内有效元素个数减一
	AdjustDown_Heap(hp, 0);//堆顶向下调整
}

HPDataType HeapTop(Heap* hp) {// 取堆顶的数据
	assert(hp);
	return hp->array[0];
}

int HeapSize(Heap* hp) {// 堆的数据个数
	assert(hp);
	return hp->size;
}

int HeapEmpty(Heap* hp) {// 堆的判空
	assert(hp);
	return hp->size == 0;//空返回1，非空返回0
}

void HeapDestroy(Heap* hp) {// 堆的销毁
	assert(hp);
	if (hp->array) {
		free(hp->array);
		hp->array = NULL;
		hp->capacity = 0;
		hp->size = 0;
	}
}

Hey小孩
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
结构体,堆空间
qq_45633736的博客
08-18 669
一、堆空间的申请与释放。 1、堆空间的特点。 堆区不像栈区一样，通过申请变量而得到，而是通过写代码调用malloc()函数而得到。 代码中定义局部变量 -> 等价于在栈区申请空间。 代码中定义全局变量 -> 等价于在bss/data区申请空间。 代码中出现了常量"hello" -> 等价于在rodata区申请空间。 代表中调用malloc函数 -> 等价于在堆区申请。 2、如何申请堆空间？如何释放释放空间？ 堆空间必须主动申请，主动释放，也就是说...
数据结构——堆排序.h
09-11
数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序
结构体创建在堆区
m0_53157173的博客
02-17 1344
char name无法修改里面字符的问题：* #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> //结构体嵌套 struct stu { int num; }; struct teacher { const char* name; //字符串指针 //char name[64]; int age; stu t; }t1; void test() { //字符串指针指向字面常量 t1
堆排序(C++)
程序员Link
10-30 817
#include using namespace std; void print(int a[], int num) { for (int i = 0; i < num; ++i) { cout << a[i] << " "; } cout << endl; } /* 初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆， 将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最
在堆区，给结构体开动态内存（大小可变）
sdnulixianrui的博客
12-13 485
#include #include #include typedef struct _student { int num; char name[30]; } Student; Student s2[4]; Student *s3[100]; Student **t; int main() { int i, n; scanf("%d", &n);
数据结构——堆.pdf
07-11
数据结构——堆 1.容易蒙圈的概念问题 ⼀般我在学习⼀个新的东西的时候都会在脑⼦⾥有⼀⼤堆问题！那么到底堆是什么？是⼀种什么样的数据结构呢？⽤堆可以来⼲什么呢？ 让我来⾃问⾃答哈：堆其实说⽩了就是⼀种这类...
高级数据结构——堆在解题中的应用.pdf
08-07
#资源达人分享计划#
数据结构——堆 练习题（英文）
01-01
将学生信息输入堆中，根据最大堆性质选出前三名。
算法和数据结构——左程云.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
算法数据结构——堆，直接便可编译通过，功能丰富
05-27
算法数据结构——堆，直接便可编译通过，功能丰富 算法数据结构——堆，直接便可编译通过，功能丰富 算法数据结构——堆，直接便可编译通过，功能丰富
xianligongdaxue——————863数据结构
12-17
数据结构是计算机科学中至关重要的基础概念，它研究如何组织和管理数据，以便高效地进行存储、检索和处理。863数据结构复习题重点涵盖了数据结构的基本概念、逻辑结构、存储结构、算法分析和评价。 1. **数据结构...
数据结构——期末复习.ppt
07-11
数据结构是计算机科学中至关重要的基础概念，它研究如何有效地组织和存储数据，以便于算法的高效执行。在数据结构的期末复习中，通常会涵盖以下几个核心知识点： 1. **算法的时间复杂度**：时间复杂度是衡量算法...
数据结构课设——小大根交替堆实现的双端优先级队列及应用
11-26
数据结构课设——小大根交替堆实现的双端优先级队列及应用 小大根交替堆是一种特殊的堆结构，它可以同时满足大根堆和小根堆的性质。在本文中，我们将对小大根交替堆实现的双端优先级队列进行详细的分析和设计。 ...
数据结构课程设计 实验报告——堆排序
06-18
堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
关于堆+结构体的重载
在人间贩卖声音
01-19 324
关于优先队列的重载： 当优先队列/堆中是结构体时，一定要先重新定义运算符或者自己定义一个比较函数。 PS：当只有两个关键字的时候，最好用pair，可以自动先比较第一个在比较第二个 法一：自己定义一个专门的结构体，用来比较 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<queue> #define ll long long using n
堆的含义以及堆结构
weixin_43848171的博客
07-02 2202
堆结构 1)堆结构就是用数组实现的完全二叉树结构 2）完全二叉树中如果每棵子树的最大值都在顶部就是大根堆 3）完全二叉树中如果每棵子树的最小值都在顶部就是小根堆 4）堆结构的插入和调整操作 5）堆结构的增大和减少 6）优先级队列结构，就是堆结构 堆排序 1.先让整个数组都变成大根堆结构，建立堆的过程 1）从上往下的方法，时间复杂度为O(NlogN) 2) 从下到上的方法，时间复杂度为O（N） 2.把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调整堆，一直周而复始，时间复杂度为O（NlogN） 3
数据结构—堆
luhaowei0066的博客
06-03 196
堆的定义：堆是一个完全二叉树 堆有两种, 一种叫小堆(小根堆, 最小堆), 一种叫大堆(大根堆, 最大堆). 以小堆为例, 这个树的根节点是这个树中的最小的元素，对于任意一个子树来说, 子树的根节点, 小于左右孩子节点的值. 以大堆为例, 这个树的根节点是这个树种的最大元素，对于任意一个子树来说, 子树的根节点, 大于左右孩子节点的值. 头文件 heap.h#pragma once #inclu...
数据结构之堆（Heap）的实现
weixin_34111819的博客
04-28 724
堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构，所以堆也叫做二叉堆。二叉堆满足二个特性： 1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。 2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。 当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于 任何一个子节点的键值时为最小堆。 最...
《数据结构与算法——c++版》
08-11
《数据结构与算法——c 版》是一本介绍数据结构和算法的学习教材。这本书以C语言为主要编程语言，全面讲解了数据结构和算法的基本概念及其常见的应用。通过学习本书，读者可以掌握C语言中常用的数据结构和算法，提高编程能力和解决实际问题的能力。 首先，书中详细介绍了数据结构的概念和分类，包括线性结构（如数组、链表、队列、栈等）和非线性结构（如树、图、堆等）。每种数据结构都给出了对应的定义、特点和常见的应用场景，方便读者理解和运用。 其次，书中深入浅出地讲解了算法的常用思想和方法，如递归、分治、贪心、动态规划等。每种算法都附有详细的实例分析和代码实现，帮助读者理解算法的原理和应用。 此外，书中还介绍了常用的数据结构和算法的分析和性能评估方法，帮助读者选择合适的数据结构和算法来解决实际问题。通过练习题和编程实践，读者可以加深对所学知识的理解和运用。 总体而言，这本教材是一本很好的学习数据结构和算法的指导书，不仅适合初学者入门，也适合已有一定基础的读者进一步提高。通过学习这本书，读者可以掌握C语言中的数据结构和算法，提高编程能力，为以后的软件开发与算法设计打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hey小孩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值