数据结构基础--堆(优先权队列ADT)

已于 2022-11-21 19:46:33 修改
阅读量576 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
于 2022-11-10 21:15:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RXY24601/article/details/127794409
版权

数据结构中的堆和栈与操作系统内存划分中的堆和栈没有关系

一、堆的定义

一个大小为n的堆是一棵包含n个结点的完全二叉树，其根节点称为堆顶。

根据堆中亲子结点的大小关系，分为大堆和小堆：
（1）最小堆：树中的每个结点的元素都小于或等于其孩子结点的元素。最小堆中堆顶存储的元素为整棵树中最小的

（2）最大堆：树中的每个结点的元素都大于或等于其孩子结点的元素。最大堆中堆顶存储的元素为整棵树中最大的

下列关键字序列为堆的是：（A）

A        100,60,70,50,32,65

B        60,70,65,50,32,100

C        65,100,70,32,50,60

D        70,65,100,32,50,60

E        32,50,100,70,65,60

F        50,100,70,65,60,32

二、堆的存储表示

所有的数组都可以表示成完全二叉树，但是不是所有的数组或完全二叉树都是堆

堆的逻辑结构：逻辑结构为完全二叉树

堆的物理结构：实际上的存储结构是数组

三、建堆算法的实现

最大堆向上调整思路：

向上调整代码实现：

//size为数组大小，child为新插入的数据位置
void AdjustUp(int *a,int size,int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child>0)
	{
		//大堆
		//if (a[child] > a[parent])
		//小堆
		if(a[child]<a[parent])
		{
			//父子数值交换
			Swap(&a[child], &a[parent]);

			//更新父子结点
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

最小堆向下调整思路：

即将其调整成最小堆，向下调整，将根结点与左右孩子中更小的那个交换

结束条件：①父亲<=小的孩子，则停止②调整至叶子结点

向下调整代码实现：

void AdjustDown(int *a,int size,int parent)
{
	assert(a);
	int child = parent * 2 + 1;//左孩子
	while (child<size)
	{
		//选更大的孩子结点，child+1为右孩子
		//if (child+1<size&&a[child+1]>a[child])
		//选更小的孩子节点
		if(child+1<size&&a[child+1]<a[child])
		{
			child++;//如果右孩子值更大/小，那么child指向右孩子
		}
		//大堆：如果大的孩子大于父亲则交换
		//if (a[child]>a[parent])
		//小堆，如果小的孩子小于父亲则交换
		if(a[child]<a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

建堆算法实现思路：

这里建堆采用向上调整，删除采用向下调整。

删除操作采取数据交换的原因，是为了避免直接删除堆顶数据，导致整个数后面顺序全部改变。

接口函数中的Push与Pop操作的时间复杂度为O(logN)

建堆操作时间复杂度为O(N)：因为叶子节点不需要堆化，所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中，需要比较和交换的节点个数，跟这个节点的高度 k 成正比。

建堆算法代码实现：

头文件：

#pragma
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<malloc.h>

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

void HeapCreate(HP* hp, HPDataType* a, int n);//构建一个堆
void HeapPrintf(HP* hp);//循环输出打印堆中元素
void Swap(HPDataType* px,HPDataType *py);
void AdjustUp(int* a, int size, int child);//向上调整
void AdjustDown(int* a,int size,int parent);//向下调整
void HeapInit(HP* hp);//堆的初始化
void HeapDestory(HP* hp);//堆销毁
void HeapPush(HP* hp,HPDataType x);//堆中插入数据
void HeapPop(HP* hp);//删除堆顶数据
HPDataType HeapTop(HP* hp);//获取堆顶数据
int HeapSize(HP* hp);//堆节点数量
bool HeapEmpty(HP* hp);//判空
void HeapSort(int* a, int n);//堆排序

源文件： 

#include"heap.h"

void HeapCreate(HP* hp,HPDataType *a,int n)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (hp->a==NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	memcpy(hp->a, a, sizeof(HPDataType) * n);
	//void *memcpy(void *str1, const void *str2, size_t n) 
	//从存储区 str2 复制 n 个字节到存储区 str1。
	hp->size = hp->capacity = n;
	HeapSort(a, n);
}
void Swap(HPDataType* px,HPDataType* py)
{
	HPDataType* tmp = *px;
	*px = *py;
	*py = tmp;
}

void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}


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

//向上调整
//size为数组大小，child为新插入的数据位置
void AdjustUp(int *a,int size,int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child>0)
	{
		//大堆
		//if (a[child] > a[parent])
		//小堆
		if(a[child]<a[parent])
		{
			//父子数值交换
			Swap(&a[child], &a[parent]);

			//更新父子结点
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//堆插入数据堆其他结点没有影响
//可能会影响它到根节点的路径上的结点关系
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	if (hp->size==hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (tmp==NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size, hp->size - 1);
}


void AdjustDown(int *a,int size,int parent)
{
	assert(a);
	int child = parent * 2 + 1;//左孩子
	while (child<size)
	{
		//选更大的孩子结点，child+1为右孩子
		//if (child+1<size&&a[child+1]>a[child])
		//选更小的孩子节点
		if(child+1<size&&a[child+1]<a[child])
		{
			child++;//如果右孩子值更大/小，那么child指向右孩子
		}
		//大堆：如果大的孩子大于父亲则交换
		//if (a[child]>a[parent])
		//小堆，如果小的孩子小于父亲则交换
		if(a[child]<a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


//再进行向下调整算法
void HeapPop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
	Swap(&hp->a[0], &hp->a[hp->size - 1]);//将堆顶数据与数组中最后一个数据交换
	hp->size--;//删除数组中的最后一个数据
	AdjustDown(hp->a, hp->size,0);//传入数组，数组的大小，向下调整起始位置
}

void HeapPrintf(HP* hp)
{
	for(int i=0;i<hp->size;i++)
	{
		printf("%d ",hp->a[i]);
	}
	printf("\n");
}

HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}

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

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

 四、堆排序

 也就是将堆中的数据进行排序，原本堆是一个完全二叉树。堆排序的目的是将结点中的数字，按照从小到大，或者从大到小的方式存储在数组中。

也就是说如果有一个大堆，那么堆顶数据原本储在数组a[0]位置处。数组a中的数字存储顺序是无序的。堆排序的意义就是将数组中的按照一定的顺序排列。

 

堆排序包括建堆和排序两个操作，建堆过程的时间复杂度是 O(n)，排序过程的时间复杂度是 O(nlogn)，所以，堆排序整体的时间复杂度是 O(nlogn)。

堆排序代码实现：

//向上调整
//size为数组大小，child为新插入的数据位置
void AdjustUp(int *a,int size,int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child>0)
	{
		//大堆
		//if (a[child] > a[parent])
		//小堆
		if(a[child]<a[parent])
		{
			//父子数值交换
			Swap(&a[child], &a[parent]);

			//更新父子结点
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}


void AdjustDown(int *a,int size,int parent)
{
	assert(a);
	int child = parent * 2 + 1;//左孩子
	while (child<size)
	{
		//选更大的孩子结点，child+1为右孩子
		//if (child+1<size&&a[child+1]>a[child])
		//选更小的孩子节点
		if(child+1<size&&a[child+1]<a[child])
		{
			child++;//如果右孩子值更大/小，那么child指向右孩子
		}
		//大堆：如果大的孩子大于父亲则交换
		//if (a[child]>a[parent])
		//小堆，如果小的孩子小于父亲则交换
		if(a[child]<a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int*a ,int n)
{
	//把a构建成堆
	for (int i = 0;i<n;i++)
	{
		AdjustUp(a, n, i);
	}
//降序排序
//	for (int i=(n-1-1)/2;i>=0;i--)
//	{
//		AdjustDown(a, n, i);
//	}
}

RXY24601
关注
专栏目录
数据结构栈ADT和队列ADT
weixin_57539783的博客
03-24 565
数据结构栈ADT和队列ADT
【ADT】第六章 堆—优先队列
CstomRita的博客
08-26 642
之前在链表ADT中涉及到了队列，LInkedList通过双链表实现了队列先进先出的功能 此次提出一个优先队列的概念，它依旧满足队列一端入队一端出队的原则，唯一的区别在于出列的工作是找出、返回并删除优先队列中的最小值 优先队列中的操作仅仅限于插入和最小值，不能排序、也不能find（非最小值） 一次insert(入队)的平均为O(1)，删除最小元(出队)平均时间O(logN) 对优先队列的实现...
堆ADT_Heap
GKHack's Blog
10-27 3421
一个大小为n的堆是一棵包含n个结点的完全二叉树, 该树中每个结点的关键字值大于等于其双亲结点的关键字值.  堆顶: 二叉树的根, 它的关键字是整棵树上最小的.(最小堆) 建堆运算时, CreatHeap()函数完成将一个以任意次序排列的元素排列, 通过向下调整建成最小堆. 实现运算AdjustDown的方法是: 向下调整heap[r]. 设tmp = hear[r], 如果tmp大于
数据结构-队列ADT
viafcccy的博客
02-19 962
队列是一端插入一端删除的数据结构，不同于栈在一端同时删除和插入 初始化后的队列ADT 但是我们可以看到此时会有一种问题就是假溢出 也就是我们入队5个元素后 将123位置的元素出列但是会发现 再次入队的话队列已经无法入队 因此我们需要引入一个循环队列的ADT 这样我们就可以只用将队列从0直接入队 但是怎样将rear游标移动到0这个位置呢？ 其实只需要套用下面的公式就可以...
数据结构：队列ADT
XU的专栏
02-06 698
队列的数组实现（循环队列 -> 充分利用空间）： http://www.cnblogs.com/kaituorensheng/archive/2013/02/28/2937865.html
数据与算法：2基本数据结构7-优先级队列.pdf
06-26
优先级队列（Priority Queue）是一种特殊的队列，它不同于一般的先进先出队列，而是每次从队列中取出的是具有最高优先权的元素。优先级队列的实现方式有多种，可以基于有序顺序表、无序顺序表、有序链表、无序链表、...
优先队列与堆的数据结构应用- Huffman编码
优先队列是一种特殊的数据结构，与传统的先进先出（FIFO）队列不同，它按照优先级来决定元素的出队顺序，即优先权最小的元素最先被删除。在存在多个优先级相同的最小元素时，可以随机选择一个或按照入队顺序删除。...
简要数据结构讲义--配合严蔚敏c版数据结构使用
05-24
### 数据结构核心知识点详解 #### 一、绪论 ##### 1. 数据结构与抽象数据类型 ...以上是关于数据结构中的核心知识点总结，涵盖了从基础概念到高级算法的各个方面。希望对学习数据结构的同学有所帮助。
数据结构上机报告4--图.pdf
11-27
数据结构中的图是一种重要的抽象数据类型，用于表示实体之间的关系。在这个数据结构上机报告中，主要关注了图的实现，特别是与最短路径和最小生成树相关的算法。以下是相关知识点的详细说明： 1. **图ADT定义**： ...
数据结构（三）之队列ADT
LinEvan
05-02 1255
队列也是表。通过数组和链表都可以实现。
数据结构ADT--简单的队列
qq_45571565的博客
07-17 167
```cpp #pragma once #include<iostream> #include<string> template<typename elem> class queu{ private: elem *list=new elem[maxsize]; int top; int back; int maxsize; public: queu(int n) { maxsize = n; top = back = 0; } ~queu() {.
【数据结构笔记05】堆栈及其顺序存储、链式存储
记录学习痕迹的公众号：Piper蛋窝
09-15 859
堆栈及其顺序存储、链式存储。
数据结构——堆栈
x18037177724的博客
11-05 834
堆栈是一种线性存储形式，通常由一个一维数组构成。栈的顺序存储通常由一个一维数组和一个记录栈顶的位置变量组成。在这里一维数组代表栈内元素，top代表栈顶元素位置。注意：top=-1的时候代表空栈，top=0代表栈内有一个元素。在这里，我爱将两种堆栈：一种是线性堆栈，一种是双向堆栈。（我们可以把堆栈形象的比喻为一个羽毛球筒，羽毛球只能一个一个装进去，再一个一个按顺序拿出来。）
数据结构 - 堆栈
xuechanba的博客
10-16 2044
本文部分图片截取自B占懒猫老师。 视频链接为：ttps://www.bilibili.com/video/BV1v741137wC. 堆栈 入栈 出栈 栈的顺序存储结构及实现 1、确定用数组的哪一端表示栈底 2、定义一个变量top来指示栈顶元素在数组中的位置。 top可以定义为指针类型也可以定义为整型。 如果定义为整型类型，我们可以让top的初始值为-1，top的值加1，变为0。然后第一个元素进栈，从而top就指向了第一个元素的位置。 3、入栈操作 总结：入栈操作，top先加1，然后在top所
数据结构-堆栈
weixin_46429290的博客
05-15 4104
数据结构-堆栈 堆栈（Stack）是一组相同数据类型的组合，具有“后进先出”的特性，所有的操作均在顶端进行。 堆栈的简介 “后进先出”可以看做是往米缸里放米，先放进去的后吃，后放进去的在顶端先吃。堆栈是一种抽象数据结构（ADT，Abstract Data Type），具有下列特性： 只能从堆栈的顶端存取数据 数据的存取符合后进先出的原则 堆栈的基本运算有5种： create 创建一个空堆栈 push 把数据存压入堆栈顶端，并返回新堆栈 pop 从堆栈顶端弹出数据，并返回新堆栈
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值