【数据结构】堆（超详细）

已于 2024-05-17 08:43:08 修改
阅读量1k 收藏 22
点赞数 39
分类专栏： 数据结构 文章标签： 数据结构
于 2024-05-14 20:37:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74897518/article/details/138818330
版权

文章目录

前言

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。在现实中我们通常把堆 (一种完全二叉树) 使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

堆的概念及结构

在这里插入图片描述

【大根堆和小根堆】：

根结点最大的堆叫做大根堆，树中所有父亲都大于或等于孩子。

根结点最小的堆叫做小根堆，树中所有父亲都小于或等于孩子。
在这里插入图片描述

堆的实现

首先新建一个工程：

Heap.h（堆的类型定义、接口函数声明、引用的头文件）
Heap.c（堆接口函数的实现）
test.c（主函数、测试栈各个接口功能）

完整的代码放在后面（包括测试代码），这里就不会展示测试的效果图。大家可以自己别敲边按测试代码测试。图解会写的很详细的，么么😙

堆的向下调整算法（建小堆为例）

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。
向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
int arr[] = {27,15,19,18,28,34,65,49,25,37};
在这里插入图片描述

思想：
1.选出左右孩子较小的一个值，
2.然后和父亲进行比较，如果比父亲小就进行交换，并将原来小的孩子的位置当成父亲继续向下进行调整，直到调整到叶子结点为止。如果比父亲大，则停止向下调整，此时该树就成小堆。

使用堆的向下调整算法，最坏的情况下（即一直需要交换结点），需要循环的次数为：h - 1次（h为树的高度）。而h = log2(N+1)（N为树的总结点数）。所以堆的向下调整算法的时间复杂度为：O(logN) 。

//交换函数
void Swap(HDataType* p1, HDataType* p2)
{
	HDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;

}

//向下调整算法
void AdjustDown(HDataType* a, int size, int parent)
{
	//假设左孩子小
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] < a[child])//确保有右孩子，如果右孩子小，更新到右边
		{
			++child;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
            //更新父亲孩子下标，
			parent = child;
			child = child * 2 + 1;
		}
		else // 如果父亲小于孩子，说明已经为小堆了，停止调整
		{
			break;
		}
	}

}

堆的向上调整算法（建小堆为例）

当我们在一个堆的末尾插入一个数据后，需要对堆进行调整，使其仍然是一个堆，这时需要用到堆的向上调整算法。
假设在这个堆int arr[] = {15,18,19,25,28,34,65,49,27,37}的末尾插入16.
在这里插入图片描述

思想：
1.将要插入孩子的值与父亲的值比较。
2.若插入孩子的值比父亲的值小，则交换插入孩子的值与父亲的值，并将父亲的位置当作新的插入孩子的值继续进行向上调整。若插入孩子的值比父亲的值大，则停止向上调整，此时该树就成小堆。

使用堆的向上调整算法，最坏的情况下（即一直需要交换结点），需要循环的次数为：h - 1次（h为树的高度）。而h = log(N+1)（N为树的总结点数）。所以堆的向上调整算法的时间复杂度也是为：O(logN) 。


//交换函数
void Swap(HDataType* p1, HDataType* p2)
{
	HDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;

}

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

堆的初始化

//初始化堆
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

销毁堆

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

堆的插入

数据插入时是插入到数组的末尾，即树形结构的最后一层的最后一个结点，所以插入数据后我们需要运用堆的向上调整算法对堆进行调整，使其在插入数据后仍然保持堆的结构。

//堆的插入
void HPPush(HP* php, HDataType x)
{
	assert(php);
	//检查空间是否足够插入，不够则扩容
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HDataType* tmp = (HDataType*)realloc(php->a, sizeof(HDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	//插入元素
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);// 从插入的元素开始，进行向上调整，保持它依然是堆
}

堆的删除(规定删堆顶的数据)

堆的删除，删除的是堆顶的元素，但是这个删除过程可并不是直接删除堆顶的数据，
1.将堆顶的数据与最后一个结点的数据交换，
2.删除堆种最后一个元素，此时左子树和右子树还是小堆
3.再对堆进行向下调整

//堆的删除(规定删堆顶的数据)
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);//确保堆不能为空
	Swap(&php->a[0], &php->a[php->size - 1]);// 将堆顶元素和最后一个元素交换
	php->size--;// 删除堆中最后一个元素
	AdjustDown(php->a, php->size, 0);// 从根节点开始，对剩下元素进行向下调整成大堆，保持它依然是堆
}

取堆顶元素

//取堆顶元素
HDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);//确保堆里有数据
	return php->a[0];//返回堆顶数据
}

判断堆是否为空

//判断堆是否为空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;//判断堆中数据是否为0
}

获取堆的个数

//获取堆的个数
int HPSize(HP* php)
{
	assert(php);
	return php->size;//返回堆中数据个数
}

完整代码（包括测试代码）

Heap.h

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


typedef  int HDataType;
typedef struct Heap
{
	HDataType* a;
	int size;
	int capacity;

}HP;

//交换函数
void Swap(HDataType* p1, HDataType* p2);
//向上调整算法
void AdjustUp(HDataType* a, int child);
//向下调整算法
void AdjustDown(HDataType* a, int size, int parent);



//初始化堆
void HPInit(HP* php);
//销毁堆
void PHDestroy(HP* php);
//堆的插入
void HPPush(HP* php, HDataType x);
//堆的删除(规定删堆顶的数据)
void HPPop(HP* php);
//取堆顶元素
HDataType HPTop(HP* php);
//判断堆是否为空
bool HPEmpty(HP* php);
//获取堆的个数
int HPSize(HP* php);

Heap.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"


//小堆
void Swap(HDataType* p1, HDataType* p2)
{
	HDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;

}

//向下调整算法
void AdjustDown(HDataType* a, int size, int parent)
{
	//假设左孩子小
	int child = parent * 2 + 1;

	while (child < size)
	{	
		if (child + 1 < size && a[child + 1] < a[child])//确保有右孩子，如果错了，更新到右边
		{
			++child;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);

			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			break;
		}
	}

}
//向上调整算法
void AdjustUp(HDataType* a, int child)//可以用递归写，没必要，用循环就可以
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}


	}

}
//初始化堆
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

//销毁堆
void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;

}

//堆的插入
void HPPush(HP* php, HDataType x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HDataType* tmp = (HDataType*)realloc(php->a, sizeof(HDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);
}

//堆的删除(规定删堆顶的数据)
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}


//取堆顶元素
HDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

//判断堆是否为空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
//获取堆的个数
int HPSize(HP* php)
{
	assert(php);
	return php->size;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"


int main()
{
	int a[] = { 4,3,7,9,1,5,8,2,8 };
	int sz = sizeof(a) / sizeof(a[0]);
	HP hp;
	HPInit(&hp);
	for (int i = 0; i < sz; i++)
	{
		HPPush(&hp, a[i]);
	}
	//int k = 5;
	//while (k--)
	//{
	//	printf("%d\n", HPTop(&hp));
	//	HPPop(&hp);
	//}
	while (!HPEmpty(&hp))
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");

	return 0;
}
会唱歌的小黄李
关注
  • 39
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Python 超详细算法与数据结构视频教程
05-06
课程的目录结构如下，每一章都有配套的文字讲义(markdown)，示例代码，视频讲解，详细的讲解一般会放在视频...python 内置常用数据结构和算法的使用。list, dict, set, collections 模块，heapq 模块 面试笔试常考算法
超详细的数据结构讲解（值得珍藏）
04-17
我们将从数据结构的定义出发，详细阐述各类数据结构的特性与操作，并结合实际案例说明其在实际问题中的应用。通过本文的阅读，读者将能够深入了解数据结构的核心知识，提升编程技能，优化算法效率。 数据结构是指...
Java超详细！Java实现数据结构PPT课件
02-24
线性数据结构动态数组（ArrayList） 链表（LinkedList） 单向链表 双向链表 循环链表 静态链表 栈（Stack） 队列（Queue） 双端队列（Deque） 循环队列 哈希表（HashTable） 树形数据结构 二叉树（BinaryTree）、...
数据结构中常见的8种排序算法，超详细
06-26
关于堆排中的向上调整算法、向下调整算法以及如何建堆（建大堆、建小堆） 快排的递归法、非递归法；递归法中又分三种方法，以及堆递归法的优化 归并排序的递归法、非递归法；非递归法中遇到越界问题的两种解决方案；...
数据结构：一篇拿捏十大排序(超详细版)
10-19
这篇超详细的文章“数据结构：一篇拿捏十大排序”深入探讨了八大常用排序算法，旨在帮助读者掌握这些核心概念。 首先，我们来详细了解这八大排序算法： 1. **冒泡排序**：是最简单的排序方法，通过重复遍历数组，...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1067
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 286
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 714
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
weixin_47808575的博客
07-22 49
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 737
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 973
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1102
24暑假刷题day15打卡 二叉树进阶
数据结构之细说链表
m0_73634434的博客
07-17 1082
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构~~顺序表
最新发布
TU^的博客
07-22 376
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构和算法（刷题）- 用栈实现队列
yunshancangcang_的博客
07-19 365
出队涉及AB两栈的迁移。这是均摊时间复杂度，均摊到每次出队上就是。只用1个栈肯定不行，得用两个栈。思考：入队的时间复杂度显然是。思路：一个栈A，一个栈B。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 176
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 992
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
数据结构 - 队列（精简介绍）
mydaily_的博客
07-19 393
循环队列（Circular Queue），也称为环形队列，是一种队列数据结构，它将队列的最后一个位置连接到队列的第一个位置，使其形成一个环。在循环队列中，队列的前端和后端都可以绕回到数组的起始位置，从而有效利用数组的空间。单端队列升级版，允许在队头和队尾都进行元素的插入删除操作。，队列中元素会根据某种规则进行优先级排序。只能从尾部插入，头部取出元素。普通队列为单端队列，先进先出（FIFO）
数据结构（下）复习
LgdCjp的博客
07-22 458
1.数据结构是一门研究非数值计算的程序设计问题中计算机的数据元素以及它们之间的关系和运算等的学科。2.基本数据结构，从逻辑上可分为线性结构和非线性结构，大体上可分成表结构、树结构、图结构 和散结构4大类表结构用于表示结点的先后次序关系，通常一个结点只有1个前驱和后继；树结构用来表示结点之间的层次关系，通常一个结点可以有多个后继，1个前驱。一个数据节点的集合以及集合中各结点之间的关系组成一个数据结构3.数据的物理结构（存储结构）要体现出逻辑结构。
python数据结构类型
06-02
5. 堆（Heap）：一种特殊的树形数据结构，通常用于实现优先队列。 6. 栈（Stack）：一种后进先出（LIFO）的数据结构。 7. 队列（Queue）：一种先进先出（FIFO）的数据结构。 8. 链表（Linked List）：由节点组成的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值