priority_queue优先队列（学习笔记）

已于 2023-02-05 20:13:16 修改
阅读量286 收藏
点赞数 4
分类专栏： 算法 文章标签： 学习 数据结构
于 2023-02-03 01:01:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73118927/article/details/128859511
版权

priority_queue优先队列的底层就是堆

在一个长度为N的数组中，如果要删除一个最小的数，并且添加一个数N次。

如果采用

for(int i=1;i<=n;i++)
{
    if(a[i]<min) min=a[i];
}

这样的方法，时间复杂度为O(n*n)。

但是如果使用堆结构，时间复杂O(n*log n）。

c++stl  priority_queue

  • 头文件<queue>
  • 定义priority_queue<数据类型>que;
  • 操作

数据类型为int时 priority_queue<int>que; 默认大顶堆

  • 大顶堆
  • 小顶堆

 当数据类型为结构体时   >为小顶堆，<为大顶堆

以下是应用

 P4779 【模板】单源最短路径（标准版）https://www.luogu.com.cn/problem/P4779

思路：dij邻接表+优先队列。先将所有源点出发的边存入优先队列，每次取队首去，将队首+队首所连接的点出发的每一条边 入队。均入队完之后，队首出队。

代码实现

#include<bits/stdc++.h>
using namespace std;
#define inf 1000000000;
int u[200000+5];
int v[200000+5];
int w[200000+5];
int first[100000+5];
int nex[200000+5];
int dis[100000+5];//源点到i的距离为dis[i]
bool book[100000+5];

struct heap{
	int dis;
	int pos;
	bool operator<(const heap &b) const {
		return this->dis>b.dis;
	}
};//堆
priority_queue<heap>que;

void build(int s)//生成堆
{	
	int k=first[s];
	heap temp;
	while(k!=-1)//遍历与s相连所有的边
	{
		temp={w[k],v[k]};
		que.push(temp);
		k=nex[k];
	}
}

int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		nex[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
	}	
	dis[s]=0;	
	build(s);//构造堆
	book[s]=true;
	int k;
	int near=0;
	book[0]=true;
	int cnt=1;
	while(!que.empty())
	{
		near=que.top().pos;//最近的那个点
		if(book[near]) 
		{
			que.pop();
			continue;
		}
		dis[near]=que.top().dis;//将这最小的边存入dis
		cnt++; 
		if(cnt==n) break;
		book[near]=true;
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		heap temp;
		while(k!=-1)//遍历与near相连所有的边
		{
			temp={que.top().dis+w[k],v[k]};
			que.push(temp);
			k=nex[k];
		}
		que.pop();
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",dis[i]);
	}
    return 0;
}

同样的思路

#include<bits/stdc++.h>
using namespace std;
#define inf 1000000000;
int u[200000+5];
int v[200000+5];
int w[200000+5];
int first[100000+5];
int nex[200000+5];
int dis[100000+5];//源点到i的距离为dis[i]
int book[100000+5];
int tail=0;
struct heap{
	int dis;
	int pos;
}dist[200000+5];//堆

void build(int s)//生成堆
{	
	int k=first[s];
	while(k!=-1)//遍历与s相连所有的边
	{
		dist[++tail].dis=w[k];
		dist[tail].pos=v[k];
		int now=tail;
		while(now>1)
		{
			if(dist[now].dis>dist[now/2].dis) break;
			heap temp=dist[now];
			dist[now]=dist[now/2]; 
			dist[now/2]=temp;
			now/=2;
		}
		k=nex[k];
	}
}

void push(heap t)
{
	dist[++tail]=t;
	int now=tail;
	while(now>1)
	{
		if(dist[now].dis>dist[now/2].dis) break;
		heap temp=dist[now];
		dist[now]=dist[now/2]; 
		dist[now/2]=temp;
		now/=2;
	}	
}

void pop()//把队首的弹出去
{
	dist[1]=dist[tail--];
	int now=1;
	while(now*2<=tail)
	{
		int ne=2*now;
		if(ne<tail&&dist[ne+1].dis<dist[ne].dis) ne++;//取较小的那堆
		if(dist[now].dis<=dist[ne].dis) return;//如果符合小顶堆，则返回
		heap temp=dist[now];
		dist[now]=dist[ne];
		dist[ne]=temp;
		now=ne;//这里走向较小的堆
	}
}

int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		nex[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
	}	
	dis[s]=0;	
	build(s);//构造堆
	book[s]=1;
	int k;
	int near=0;
	book[0]=1;
	while(tail>0)
	{
		near=dist[1].pos;//最近的那个点
		if(book[near]==1) 
		{
			pop();
			continue;
		}
		dis[near]=dist[1].dis;//将这最小的边存入dis
		book[near]=1;
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		while(k!=-1)//遍历与near相连所有的边
		{
			push((heap){dist[1].dis+w[k],v[k]});
			k=nex[k];
		}
		pop();
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",dis[i]);
	}
    return 0;
}

手写堆

如有建议，求告知

订正

上面那份AC代码没有运用贪心思想，将许多比原来长的边入队了，耗费了无意义的时间与空间。

以下代码为贪心优化

#include<bits/stdc++.h>
using namespace std;
#define inf 1000000000;
int u[200000+5];
int v[200000+5];
int w[200000+5];
int first[100000+5];
int nex[200000+5];
int dis[100000+5];//源点到i的距离为dis[i]
bool book[100000+5];

struct heap{
	int dis;
	int pos;
	bool operator<(const heap &b) const {
		return this->dis>b.dis;
	}
};//堆
priority_queue<heap>que;

void build(int s)//生成堆
{	
	int k=first[s];
	heap temp;
	while(k!=-1)//遍历与s相连所有的边
	{
		temp={w[k],v[k]};
		que.push(temp);
		k=nex[k];
	}
}

int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		nex[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
	}	
	dis[s]=0;	
	build(s);//构造堆
	book[s]=true;
	int k;
	int near=0;
	book[0]=true;
	int cnt=1;
	while(!que.empty())
	{
		near=que.top().pos;//最近的那个点
		if(book[near]) 
		{
			que.pop();
			continue;
		}
		dis[near]=que.top().dis;//将这最小的边存入dis
		cnt++; 
		if(cnt==n) break;
		book[near]=true;
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		heap temp;
		while(k!=-1)//遍历与near相连所有的边
		{
			if(dis[v[k]]>dis[near]+w[k])//贪心
			{
				temp={que.top().dis+w[k],v[k]};
				que.push(temp);
			}			
			k=nex[k];
		}
		que.pop();
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",dis[i]);
	}
    return 0;
}

时间对比   贪心（上）

终于，手打堆过了（哭死）

AC代码

#include<bits/stdc++.h>
using namespace std;
#define inf 1000000000;
int u[200000+5];
int v[200000+5];
int w[200000+5];
int first[100000+5];
int nex[200000+5];
int dis[100000+5];//源点到i的距离为dis[i]
int book[100000+5];
int tail=0;
int postion[100000+5];//postion[i]为i在队列中的位置
struct heap{
	int dis;
	int pos;//i->pos
}que[100000+5];//堆

void push(heap t)
{
	que[++tail]=t;
	int now=tail;
	postion[que[now].pos]=now;
	while(now>1)
	{
		if(que[now].dis>que[now/2].dis) 
		{
			break;
		}
		heap temp=que[now];
		que[now]=que[now/2]; 
		que[now/2]=temp;
		postion[que[now/2].pos]=now/2;
		postion[que[now].pos]=now;
		now/=2;
	}	
}

void build_que(int n)//生成堆
{	
	for(int i=1;i<=n;i++)
	{
		push((heap){dis[i],i});
	}
}

void pop()//把队首的弹出去
{
	que[1]=que[tail--];
	postion[que[1].pos]=1;
	int now=1;
	heap temp;
	while(now*2<=tail)
	{
		int ne=2*now;
		if(ne<tail&&que[ne+1].dis<que[ne].dis) ne++;//取较小的那堆
		if(que[now].dis<=que[ne].dis) return;//如果符合小顶堆，则返回
		temp=que[now];
		que[now]=que[ne];
		que[ne]=temp;
		postion[que[now].pos]=now;//更新postion
		postion[que[ne].pos]=ne;		
		now=ne;//这里走向较小的堆
	}
}
void renew(int now)//向上调整
{
	heap temp;
	while(now>1)
	{
		if(que[now].dis>que[now/2].dis)
		{
			break;
		}
		temp=que[now];
		que[now]=que[now/2];
		que[now/2]=temp;
		postion[que[now].pos]=now;
		postion[que[now/2].pos]=now/2;		
		now/=2;
	}
}
void build_dis(int s)
{
	int k=first[s];
	while(k!=-1)//遍历与s相连所有的边
	{
		if(dis[v[k]]>w[k])
		{
			dis[v[k]]=w[k];
		} 
		k=nex[k];
	}	
}
int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
		nex[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
		postion[i]=i;
	}	
	dis[s]=0;	
	build_dis(s);
	build_que(n);//构造堆
	book[s]=1;
	int k;
	int near=0;
	while(tail>0)
	{
		near=que[1].pos;//最近的那个点
		if(book[near]==1) 
		{
			pop();
			continue;
		}
		dis[near]=que[1].dis;//将这最小的边存入dis
		book[near]=1;
		pop();
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		while(k!=-1)//遍历与near相连所有的边
		{
			if(dis[v[k]]>dis[near]+w[k])//贪心
			{
				dis[v[k]]=dis[near]+w[k];
				que[postion[v[k]]].dis=dis[v[k]];
				renew(postion[v[k]]);
			}
			k=nex[k];
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",dis[i]);
	}
    return 0;
}

应该是要把pop提前，不能在最后才pop。因为边有0权值，新插入的可能会占队首。

至于为什么会比优先队列快，

这是因为优先队列是动态开辟内存，而开辟内存是集齐消耗时间的。

RealmElysia
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
STL_Sources:学习《 STL源码剖析》，存放相关的个人代码及学习笔记
03-23
5. **适配器容器**：如stack（栈）、queue（队列）和priority_queue（优先队列），它们是基于其他基础容器（如vector或deque）的封装，提供了特定的数据结构行为。 6. **智能指针**：虽然不是STL的原始部分，但在...
算法笔记学习(7).pdf
10-28
4. **数据结构**：笔记中提到了C++标准模板库（STL），包括`vector`（变长数组）、`set`（集合）、`string`（字符串）、`map`（映射）、`queue`（队列）、`priority_queue`（优先队列）、`stack`（栈）、`pair`...
PriorityQueue-数组（二叉堆）
csdn_ygy的博客
10-03 700
field //默认初始化大小 private static final int DEFAULT_INITIAL_CAPACITY = 11; //队列内置为数组，实际为数据结构中的二叉堆 transient Object[] queue; // non-private to simplify nested class access //容量大小
PriorityQueue源码分析
kevin的博客
08-21 130
PriorityQueue是一个优先队列，传统的队列是先入先出FIFO模型，但是优先队列跟传统队列不一样，优先队列会根据优先级来决定谁先出队，优先队列的底层数据结构是堆用堆的好处是，每次入队和出队后，调整堆的时间复杂度为log（n）。 底层数据结构 上边提到优先队列的底层数据结构是堆，那么堆的底层数据结构是数组 //队列底层是数组 transient Object[] queue;...
C++ STL priority_queue容器适配器详解
Harrytsz的博客
06-17 380
priority_queue 容器适配器模拟的也是队列这种存储结构，即使用此容器适配器存储元素只能“从一端进（称为队尾），从另一端出（称为队头）”，且每次只能访问 priority_queue 中位于队头的元素。 但是，priority_queue 容器适配器中元素的存和取，遵循的并不是 “First in,First out”（先入先出）原则，而是“First in，Largest out”原则。直白的翻译，指的就是先进队列的元素并不一定先出队列，而是优先级最大的元素最先出队列。 注意，“First i
C++ 优先队列priority_queue（同一优先级数据顺序）
bb_iot的博客
04-03 1317
c++ 优先级队列priority_queue使用方法，队列中同一优先级数据的出队顺序等
C/C++编程：优先队列priority_queue
OceanStar的博客
07-16 3456
> priority_queue本质是一个堆。 1 . 头文件是#include<queue> 2 . 关于priority_queue中元素的比较 　　模板申明带3个参数：priority_queue<Type, Container, Functional>，其中Type 为数据类型，Container为保存数据的容器，Functional 为元素比较方式。 　　Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里
12_总结一下消息队列相关问题的面试技巧.zip
11-13
消息队列在IT行业中，尤其是Java领域，是一个至关重要的技术组件，它被广泛应用于系统解耦、异步处理、削峰填谷等场景...在准备面试时，可以参考笔记和PPT中的内容，深入学习并加以实践，以便更好地应对各种面试挑战。
数据结构 栈和队列PPT
06-28
7. 特殊类型的队列：优先队列（Priority Queue），用于处理具有优先级的元素，如最小堆实现。 8. 双端队列（Deque，Double-ended Queue）：支持在两端进行插入和删除操作，常用于实现滑动窗口最大值等算法。 在学习...
C++进阶STL源码笔记
11-15
- `priority_queue`：堆结构，总是保持顶部元素最大（或最小，取决于实现）。 4. 函数对象（Functors）： 也称为仿函数，它们是具有`()`操作符的对象，可以作为函数调用。STL中的排序和查找算法通常接受函数对象...
优先队列priority_queue（c++）
weixin_54237119的博客
04-05 2856
priority_queue
C++ STL之priority_queue的使用及模拟实现
最新发布
czh1592272237的博客
01-24 1066
本篇文章详细讲述了STL中priority_queue的使用及模拟实现。
priority_queue用法详解
Grady_Ne的博客
09-13 2163
一  priority_queue常用函数实例解析 (1) push() push(x) 令x入队，时间复杂度为O(log N), 其中 N 为当前优先队列中元素的个数 (2) top() 获得队首元素(即堆顶元素)，时间复杂度为O(1). (3) pop() 令队首元素(即堆顶元素)出队，时间复杂度为O(log N). (4) empty() 检测优先队列是否为空，返回 true则空，返
C++ STL学习之【优先级队列】
北 海的博客
05-04 9967
优先级队列是容器适配器中的一种，常用来进行对数据进行优先级处理，比如优先级高的值在前面，这其实就是初阶数据结构中的堆，它俩本质上是一样东西，底层都是以数组存储的完全二叉树，不过优先级队列中加入了泛型编程的思想，并且属于STL中的一部分
C++STL之优先级队列详解
小赵小赵福星高照的博客
12-13 4041
priority_queue 文章目录priority_queuepriority_queue的使用priority_queue在OJ中的使用数组中第k个最大元素priority_queue模拟实现push的模拟实现pop模拟实现迭代器区间构造函数模拟实现size的模拟实现empty的模拟实现top的模拟实现swap的模拟实现仿函数typename仿函数的变异玩法 翻译： 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。 此上下文类似于堆，在堆中可以随时插入元
C++ STL priority_queue的正确使用方法
Ibelievesunshine的博客
05-09 5331
priority_queue相对于queue的不同之处在于：优先队列实现了内部自动排序，可根据自己需要自定义排序规则，可以自己编写函数或者仿函数用于内部优先级的确定。//priority_queue的正确使用方法 #include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;vector&gt; using namespace std;...
认真研究队列中的优先级队列PriorityQueue
小小默：进无止境
10-10 1338
# **【1】 基础概念** PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以看出来 。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190128153955257.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6L
priority_queue
头秃程序员的日常
08-15 246
priority_queue 　　priority_queue 优先队列，其底层是用堆来实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。 　　在优先队列中，没有 front() 函数与 back() 函数，而只能通过 top() 函数来访问队首元素（也可称为堆顶元素），也就是优先级最高的元素。 一、基本数据类型的优先级设置 此处指的基本数据类型就是 int 型，doubl...
C++STL详解（七）——priority_queue的使用和模拟实现
清欢Allen的技术博客
03-14 392
优先级队列默认使用vector作为底层的存储的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priorityda_queue。注意默认情况下priority_queue是大堆。方式一使用的是vector作为底层存储容器，内部为构造为大堆结构。//大堆 priority_queue < int , vector < int > , less < int >> q1;方式二。
STL之priority_queue优先队列stl priority_queu
10-07
STL中的priority_queue是一个优先队列的数据结构，它可以按照一定的规则自动排序元素。默认情况下，priority_queue以降序的方式排序元素，即最大元素位于队列的顶部。在STL中，priority_queue是使用堆算法实现的。 可以通过以下两种方式创建priority_queue对象： 1. 使用默认的构造函数创建一个空的优先队列：priority_queue<int> q; 2. 使用自定义的排序规则创建一个优先队列：priority_queue<int, vector<int>, greater<int>> q; 对于第一种方式，队列会按照元素的降序出队，即最大的元素会先出队。而对于第二种方式，队列会按照元素的升序出队，即最小的元素会先出队。 在STL中，priority_queue是基于堆的数据结构，底层使用了make_heap()、push_heap()和pop_heap()等算法来实现。make_heap()算法可以将一个无序的序列转化为一个堆，push_heap()算法可以将一个新的元素插入到堆中，并保持堆的性质，pop_heap()算法可以将堆顶元素移除，并保持堆的性质。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值