数据结构之优先权队列

已于 2022-10-03 22:05:34 修改
阅读量3.4k 收藏 24
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2022-10-02 15:56:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35500719/article/details/127142965
版权

文章目录

一、什么是优先权队列

（一）定义

优先权队列 (priority queue) 是 0 个或多个元素的集合，每个元素都有一个优先权或值。

普通队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用 堆 数据结构来实现优先权队列。

在实际应用中，如 果 值越小， 优先 级 越 高，则 使用最 小 堆即可，否则使用最大堆。

根据最小堆的定义， 堆顶元素是堆中具有最小值的元素，在 最 小 堆的顺序存储结构中， 堆顶
元素处于顺序表的第一个元素位置。因此，从优先权队列中删除最高优先级的元素（即堆顶元素）的操作是容易实现的 ，只需取出和删除堆顶元素即可 。但删除堆顶元素后，必须将堆中剩余元素重新调整成堆。同样，当有新元素插入队列时 ，也必须 重新调整，使之成 为最小堆。

（二）优先权队列结构体

typedef struct priorityQueue
{
	ElemType* elements;
	int n;
	int maxSize;
}PriorityQueue;

（三）优先权队列存储结构

请添加图片描述

（四）向上调整运算详解

在 Insert() 运笋中，新元素 x 加入优先权队列时， 该元素首先被存储干堆底元素（堆中的最后一个元素）的下一个单元。由于在原先符合最小堆的序列尾部添加了 一个元素，很 可能使得新的序列不再满足最小堆要求，因此需要对新增加的尾部元素执行向上调整运算 AdjustUp。

v o i d   A d j u s t U p ( E l e m t y p e   h e a p [ ] ,   i n t   c u r r e n t ) void \ AdjustUp(Elemtype \ heap[], \ int \ current) void AdjustUp(Elemtype heap[], int current)

（五）向上调整算法实例

请添加图片描述

二、优先权队列的实现

（一）创建优先权队列

// 创建最大存储容量为 maxSize 空的优先权队列结构体
void CreatePQ(PriorityQueue* pqueue, int maxSize)
{
	pqueue->elements = (ElemType*)malloc(sizeof(ElemType) * maxSize);
	if (!pqueue->elements)
		return Error;
	pqueue->maxSize = maxSize;
	pqueue->n = 0;
}

（二）销毁优先权队列

// 销毁优先权队列
void DestoryPQ(PriorityQueue* pqueue)
{
	free(pqueue->elements);
	pqueue->n = 0;
	pqueue->maxSize = 0;
}

（三）判断队列是否为空

// 判断是否为空
int IsEmpty(PriorityQueue* pqueue)
{
	return pqueue->n == 0 ? True : False;
}

（四）判断队列是否为满

// 判断是否为满
int IsFull(PriorityQueue* pqueue)
{
	return pqueue->n == pqueue->maxSize ? True : False;
}

（五） 返回队列的元素个数

// 返回队列的元素个数
int Size(PriorityQueue* pqueue)
{
	return pqueue->n;
}

（六）向优先权队列中插入元素

// 向优先权队列中插入元素
void Insert(PriorityQueue* pqueue, ElemType x)
{
	if (IsFull(pqueue))
		return Error;
	pqueue->elements[pqueue->n] = x;
	pqueue->n++;
	AdjustUp(pqueue->elements, pqueue->n - 1);

}

（七）取出优先权最高的元素

// 取出优先权队列中优先权最高的元素，以 x 返回，并且在队列中删除它
void Remove(PriorityQueue* pqueue, ElemType* x)
{
	if (IsEmpty(pqueue) || IsFull(pqueue))
		return Error;
	*x = pqueue->elements[0];
	pqueue->n--;
	pqueue->elements[0] = pqueue->elements[pqueue->n];
	AdjustDown(pqueue->elements, 0, pqueue->n - 1);

}

（八）向上调整算法

//  向上调整算法
void AdjustUp(ElemType heap[], int current)
{
	int p = current;
	ElemType temp;
	while (p > 0)
	{
		if (heap[p] < heap[(p - 1) / 2])
		{
			temp = heap[p];
			heap[p] = heap[(p - 1) / 2];
			heap[(p - 1) / 2] = temp;
			p = (p - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

（九）向下调整算法

void AdjustDown(ElemType heap[], int current, int border)
{
	int p = current;
	int minChild;
	ElemType temp;
	// p 不是叶子结点	 说明 p 结点 有左孩子 或者 有左孩子且有右孩子
	while (2 * p + 1 <= border)
	{
		// 如果右孩子存在 且 左孩子大于右孩子
		if ((2 * p + 2 <= border) && heap[2 * p + 1] > heap[2 * p + 2])
		{
			minChild = 2 * p + 2;
		}
		else  // 不存在右孩子 或 左孩子小于右孩子
		{
			minChild = 2 * p + 1;
		}
		if (heap[p] <= heap[minChild])
			break;
		else
		{
			// 交换变量的值
			temp = heap[p];
			heap[p] = heap[minChild];
			heap[minChild] = temp;
			p = minChild;
		}
	}
}

（十）打印队列

void PrintPQ(PriorityQueue* pqueue)
{
	for (int i = 0; i < pqueue->n; i++)
	{
		printf("%d ", pqueue->elements[i]);
	}
	printf("\n");
}

三、创建优先权队列实例

创建一个空的优先权队列，依次插入以下元素
{ 71 , 74 , 2 , 72 , 54 , 93 , 52 , 28 } \{71, 74, 2, 72, 54, 93, 52, 28 \} {71,74,2,72,54,93,52,28}
有：

步骤优先权队列的状态
插入 71 后71
插入 74 后7174
插入 2 后27471
插入 72 后2727174
插入54 后254717472
插入 93 后25471747293
插入 52 后2545274729371
插入 28 后228525472937174
执行两次 Remove()525472937174

四、全部代码

#include <stdio.h>
#define ElemType int
#define Error -1
#define True 1
#define False 0
#define MaxSize 10

typedef struct priorityQueue
{
	ElemType* elements;
	int n;
	int maxSize;
}PriorityQueue;

void CreatePQ(PriorityQueue* pqueue, int maxSize);			// 创建最大存储容量为 maxSize 空的优先权队列结构体
void DestoryPQ(PriorityQueue* pqueue);						// 销毁优先权队列
int IsEmpty(PriorityQueue* pqueue);							// 判断是否为空
int IsFull(PriorityQueue* pqueue);							// 判断是否为满
void Insert(PriorityQueue* pqueue, ElemType x);				// 向优先权队列中插入元素
void Remove(PriorityQueue* pqueue, ElemType* x);			// 取出优先权队列中优先权最高的元素，以 x 返回，并且在队列中删除它
void AdjustUp(ElemType heap[], int current);				// 向上调整算法
void AdjustDown(ElemType heap[], int current, int border);	// 向下调整算法



// 创建最大存储容量为 maxSize 空的优先权队列结构体
void CreatePQ(PriorityQueue* pqueue, int maxSize)
{
	pqueue->elements = (ElemType*)malloc(sizeof(ElemType) * maxSize);
	if (!pqueue->elements)
		return Error;
	pqueue->maxSize = maxSize;
	pqueue->n = 0;
}

// 销毁优先权队列
void DestoryPQ(PriorityQueue* pqueue)
{
	free(pqueue->elements);
	pqueue->n = 0;
	pqueue->maxSize = 0;
}

// 判断是否为空
int IsEmpty(PriorityQueue* pqueue)
{
	return pqueue->n == 0 ? True : False;
}

// 判断是否为满
int IsFull(PriorityQueue* pqueue)
{
	return pqueue->n == pqueue->maxSize ? True : False;
}

// 返回队列的元素个数
int Size(PriorityQueue* pqueue)
{
	return pqueue->n;
}

// 向优先权队列中插入元素
void Insert(PriorityQueue* pqueue, ElemType x)
{
	if (IsFull(pqueue))
		return Error;
	pqueue->elements[pqueue->n] = x;
	pqueue->n++;
	AdjustUp(pqueue->elements, pqueue->n - 1);

}

// 取出优先权队列中优先权最高的元素，以 x 返回，并且在队列中删除它
void Remove(PriorityQueue* pqueue, ElemType* x)
{
	if (IsEmpty(pqueue) || IsFull(pqueue))
		return Error;
	*x = pqueue->elements[0];
	pqueue->n--;
	pqueue->elements[0] = pqueue->elements[pqueue->n];
	AdjustDown(pqueue->elements, 0, pqueue->n - 1);

}

//  向上调整算法
void AdjustUp(ElemType heap[], int current)
{
	int p = current;
	ElemType temp;
	while (p > 0)
	{
		if (heap[p] < heap[(p - 1) / 2])
		{
			temp = heap[p];
			heap[p] = heap[(p - 1) / 2];
			heap[(p - 1) / 2] = temp;
			p = (p - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void AdjustDown(ElemType heap[], int current, int border)
{
	int p = current;
	int minChild;
	ElemType temp;
	// p 不是叶子结点	 说明 p 结点 有左孩子 或者 有左孩子且有右孩子
	while (2 * p + 1 <= border)
	{
		// 如果右孩子存在 且 左孩子大于右孩子
		if ((2 * p + 2 <= border) && heap[2 * p + 1] > heap[2 * p + 2])
		{
			minChild = 2 * p + 2;
		}
		else  // 不存在右孩子 或 左孩子小于右孩子
		{
			minChild = 2 * p + 1;
		}
		if (heap[p] <= heap[minChild])
			break;
		else
		{
			// 交换变量的值
			temp = heap[p];
			heap[p] = heap[minChild];
			heap[minChild] = temp;
			p = minChild;
		}
	}
}

void PrintPQ(PriorityQueue* pqueue)
{
	for (int i = 0; i < pqueue->n; i++)
	{
		printf("%d ", pqueue->elements[i]);
	}
	printf("\n");
}


int main()
{
	PriorityQueue* pqueue = malloc(sizeof(PriorityQueue));

	CreatePQ(pqueue, MaxSize);

	Insert(pqueue, 71);
	PrintPQ(pqueue);

	Insert(pqueue, 74);
	PrintPQ(pqueue);

	Insert(pqueue, 2);
	PrintPQ(pqueue);

	Insert(pqueue, 72);
	PrintPQ(pqueue);
	return 0;
}
数据结构优先队列
04-12
数据结构优先队列，是一个简易版优先队列，输入数据及权值可以对其进行插入，删除等操作。
数据结构实现优先权队列
12-01
#include #include //#include #define N 5 const int maxpqsize=50; template class pQueue { public: pQueue(); virtual ~pQueue(){delete []pqelements;} Type pqinsert(const Type &item);............
数据结构之优先队列
weixin_34187822的博客
10-17 141
模型 优先队列是允许至少下列两种操作的数据结构：插入，和删除最小者。 插入等价入队，删除等价出队。 二叉堆 二个性质： 结构性 堆序性 结构性质 堆是一颗被完全填满的二叉树，有可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树。 利用数组表示二叉堆 一个堆数据结构由一个数组，一个代表最大值的整数以及当前的堆大小组成。 1.struct H...
数据结构优先级队列PriorityQueue
最新发布
Freedom的博客
11-25 2523
我们使用大根堆来进行排序，将0下标值与最后下标值进行交换，end为最后下标值，然后向下筛选重新获取最大的节点值，每次的有效元素数量-1（由最后一个下标开始–直到为0，获取由小到大的元素）。而优先级队列(PriorityQueue)指的是具有优先级别的队列(特殊队列)，根据指定类型的大小，每次出队的元素都是该类型中最大或者是最小的值，具有优先级。删除元素我们可以将对首的元素将队尾的元素进行互换，并将队尾元素的下标值删除，后续进行覆盖，然后通过向下筛选，设定根节点为0下标互换的位置，进行向下筛选。
数据结构——优先队列
qq_61350148的博客
08-05 3219
详细讲解了优先队列的大顶堆实现，并介绍了优先队列的应用。
数据结构——优先级队列(堆)
qq_62274623的博客
07-17 2769
优先级队列(堆)超详细解答，速看！
数据结构：优先队列
TOEFL_ITLS的博客
10-12 391
一般我们前面介绍的队列，队列的一个特性是先进先出。但是在作业调度的过程中我们总是希望很短的作业可以优先处理，这样我们就不用一味的等待短的作业而花费很长的时间去处理。但是同时有些短的但是很重要的作业也应该享有优先权。 优先队列至少允许以下两种操作，insert（插入）和 deleteMin（删除最小项）。insert 操作等同于 enqueue（入队），而 deleteMin 则是队列操作的 deq
优先权队列
04-18
优先权队列是一种特殊的数据结构，它按照优先级顺序对元素进行操作，具有高效查找、删除和插入元素的能力。在C++的Standard Template Library（STL）中，优先权队列（priority_queue）是一个容器适配器，它提供了一...
数据与算法：2基本数据结构7-优先级队列.pdf
06-26
数据结构与算法之优先级队列 优先级队列（Priority Queue）是一种特殊的队列，它不同于一般的先进先出队列，而是每次从队列中取出的是具有最高优先权的元素。优先级队列的实现方式有多种，可以基于有序顺序表、无序...
基于分布式动态优先权队列的CAN总线实时性仿真研究.pdf
08-11
根据提供的文档内容，以下是关于标题“基于分布式动态优先权队列的CAN总线实时性仿真研究”的详细知识点解析： 1. CAN总线技术应用背景与实时性重要性： 文档开篇提到CAN（Controller Area Network，控制器局域网络...
队列，栈，克鲁斯卡尔，约瑟夫生死者游戏等数据结构代码.rar
08-17
本资源包含与数据结构相关的代码实现，包括队列、栈、克鲁斯卡尔算法和约瑟夫环问题，分别用C语言和C++编写。下面我们将详细探讨这些主题。 1. **队列**： 队列是一种先进先出（FIFO，First In First Out）的数据...
数据结构-优先队列
12-04 421
优先队列特点 这里的特点，主要是和普通队列比较： 普通队列： 先进先出，后进后出 优先队列：出队和入队顺序无关，和优先级有关。 思路 优先队列，也是队列，因此需要实现队列接口： public interface Queue<E> { int getSize(); default boolean isEmpty() { return getSize...
【数据结构】优先队列
qq_38243831的博客
11-26 570
特征 和入队顺序无关，总是最大的元素优先出队。 如果说栈是每次输最近进入的元素，队列是每次输出最先进入的元素，那么优先队列就是每次输出优先级最大的元素。 API 优先队列是一种抽象数据类型，他表示了一组值和对这些值的一些操作。我们不一定要用某种固定的存储和操作方式来实现它，只要满足它的特征那它就是优先队列。但怎样才能高效实现它呢？先列出一份API： public class MAXPQ<T extends Comparable> 用途 MaxPQ() 创建一个优先队列 Ma
数据结构—优先队列
奔跑的蜗牛蒋
01-02 285
优先队列是允许至少下列两种操作的数据结构：Insert（插入）、DeleterMin（删除最小者）。它的工作室找出、返回、删除优先队列最小的元素。 插入操作等于Enqueue（入队）、而DeteMin则是队列中Dequeue（出队）在优先队列中的等价操作。DeterMin函数也变更它的输入。 二叉堆：结构性、堆序性 堆是一棵被完全填满的二叉树。 一棵高为h的完全二叉树有2
深入理解数据结构：栈、队列及算法应用解析
在数据结构的学习中，栈和队列是非常基础且重要的结构，它们的原理和应用场景是计算机科学中的核心概念。本压缩包内包含了多个相关的程序和案例，用于深入理解和实践栈和队列的操作。" 知识点一：栈的定义 栈是一种...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

亦是远方

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

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

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

打赏作者

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

抵扣说明：

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

余额充值