C++【STL】之priority_queue学习

最新推荐文章于 2024-10-08 08:54:31 发布
最新推荐文章于 2024-10-08 08:54:31 发布
阅读量938 收藏 4
点赞数 3
分类专栏： C++ 文章标签： c++ STL 数据结构 优先级队列 priority_queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cw412524/article/details/131353076
版权

优先级队列

优先级队列priority_queue也是STL库中容器适配器的一种，常用于进行数据优先级的处理，说到这儿是不是发现有些熟悉，没错它和我们之前讲解的堆本质上就是一个东西，底层都是数组存储的完全二叉树，它在STL库中进行了完美的封装并加入了泛型编程的思想呈现出来

文章目录：

1. 优先级队列的使用

  1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

  2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

  3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

  4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
    empty()：检测容器是否为空
    size()：返回容器中有效元素个数
    front()：返回容器中第一个元素的引用
    push_back()：在容器尾部插入元素

  5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

  6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

1.1 构造函数

优先级队列有两种构造方式，可以使用默认构造一个空对象，也可以通过迭代器区间进行构造

默认构造

int main()
{
	priority_queue<int> pq;	//默认构造一个空对象
	cout << typeid(pq).name() << endl;
	return 0;
}

默认的比较方式为less，会生成大堆

迭代器区间构造

int main()
{
	vector<int> v = { 1, 2, 3, 4, 5, 6 };
	priority_queue<int, deque<int>, greater<int>> pq(v.begin(), v.end());	//生成小堆
	cout << typeid(pq).name() << endl;

	while (!pq.empty())
	{
		//打印堆中元素
		cout << pq.top() << " ";
		pq.pop();
	}
	return 0;
}

这里将比较方式改为 greater 后，就会生成 小堆

1.2 常用接口

这里列举常用接口的使用，感兴趣的大佬们可以前往官方文档了解更多细节

  • empty()接口：判空
  • size()接口：查看大小
  • top()接口：查看堆顶元素
  • push()：向堆中插入元素
  • pop()：删除堆顶元素
int main()
{
	vector<int> v = { 24,45,33,12,65,88,52,66 };
	priority_queue<int> pq(v.begin(), v.end());	//默认生成大堆
    
	cout << "empty：" << pq.empty() << endl; //判空
	cout << "size：" << pq.size() << endl; //查看大小
	cout << "top：" << pq.top() << endl; //查看堆顶元素
	cout << "------------------------" << endl;

	//插入操作
	pq.push(8);
	pq.push(112);
	cout << "empty：" << pq.empty() << endl;
	cout << "size：" << pq.size() << endl;
	cout << "top：" << pq.top() << endl;
	cout << "------------------------" << endl;

	//删除堆顶元素
	pq.pop();
	pq.pop();
	cout << "empty：" << pq.empty() << endl;
	cout << "size：" << pq.size() << endl;
	cout << "top：" << pq.top() << endl;
	cout << "------------------------" << endl;
	return 0;
}

1.3 优先级切换

创建优先级队列时，默认的比较方式缺省值为less，使用的是仿函数，默认生成大堆，想要创建小堆的话，需要将比较方式设置为grater，不过小于less是大堆，大于grater是小堆，嗯…这就点奇怪

注意：

如果要修改比较方式的话，模板参数2的底层容器也需要指明，因为比较方式是模板参数3，缺省参数规定不能跳跃缺省

priority_queue<int, deque<int>, greater<int>> pq(v.begin(), v.end());	//生成小堆

2. 优先级队列模拟实现

我们先来实现没有加入仿函数的版本

2.1 push方法

插入数据，只需尾插数据，然后遵循大小堆的规则将父子节点进行比较，向上调整即可

//向上调整
void adjust_up(int child)
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
    	//大堆 parent > chiled
        if (_con[child] > _con[parent])
        {
            swap(_con[child], _con[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

void push(const T& val)
{
    _con.push_back(val);
    adjust_up(_con.size() - 1);
}

2.2 pop方法

删除数据，只需将堆顶数据交换到堆底，删除堆底元素，然后遵循大小堆的规则将父子节点进行比较，从堆顶向下调整即可

//向下调整
void adjust_down(int parent)
{
    size_t child = parent * 2 + 1;
    while (child < _con.size())
    {
        if (child + 1 < _con.size()
            && _con[child + 1] > _con[child) //找出较大的孩子
        {
            ++child;
        }

        //大堆 parent > child
        if (com(_con[parent], _con[child]))
        {
            swap(_con[child], _con[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void pop()
{
    swap(_con[0], _con[_con.size() - 1]);
    _con.pop_back();
    adjust_down(0);
}

2.3 判空大小堆顶

empty()方法：判空，复用底层容器的判空接口即可

bool empty()
{
    return _con.empty();
}

size()方法：查看大小，复用底层容器查看大小接口即可

size_t size()
{
    return _con.size();
}

top()方法：查看堆顶元素：返回数组首元素即可

const T& top()
{
    return _con[0];
}

想要使用小堆的话需要将代码中的 > 改为 <，这样的手动切换方式，就显得太挫了，那么是否有姐解决方法呢？答案是有的，那就是本文的周重头戏，使用仿函数来解决

2.4 仿函数

仿函数的主要作用是 借助类和运算符重载，做到同一格式兼容所有函数

下面我们用两个比较大小的仿函数来解决上面优先级队列的实现中不能大小堆自由切换的问题

template<class T>
struct less
{
    bool operator()(const T& x, const T& y)
    {
        return x < y;
    }
};

template<class T>
struct greater
{
    bool operator()(const T& x, const T& y)
    {
        return x > y;
    }
};

再加入第三个模板参数，也就是用于比较大小的仿函数，缺省值为less

template<class T, class Container = vector<T>, class Comapre = less<T>>

当需要进行逻辑比较时，只需要调用 operator() 进行比较即可

下面来改写向上调整和向下调整

void adjust_up(int child)
{
    Comapre com;
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        //child > parent -> parent < child
        //if (Comapre()(_con[parent], _con[child]) //匿名
        if (com(_con[parent], _con[child]))
        {
            swap(_con[child], _con[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

void adjust_down(int parent)
{
    size_t child = parent * 2 + 1;
    while (child < _con.size())
    {
        Comapre com;
        if (child + 1 < _con.size()
            && com(_con[child], _con[child + 1])) //找出较大的孩子
        {
            ++child;
        }

        //parent < child
        if (com(_con[parent], _con[child]))
        {
            swap(_con[child], _con[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

这样就可以实现大小堆的自由切换了

2.5 完整代码

#pragma once
#include <iostream>
#include <list>
#include <vector>
#include <deque>
#include <algorithm>
#include <string>
using namespace std;

namespace sakura
{
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	template<class T, class Container = vector<T>, class Comapre = less<T>>
	class priority_queue
	{
	public:
		void adjust_up(int child)
		{
			Comapre com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//child > parent -> parent < child
				//if (Comapre()(_con[parent], _con[child]) //匿名
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(int parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				Comapre com;
				if (child + 1 < _con.size()
					&& com(_con[child], _con[child + 1])) //找出较大的孩子
				{
					++child;
				}

				//parent < child
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& val)
		{
			_con.push_back(val);
			adjust_up(_con.size() - 1);
		}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
        
		const T& top()
		{
			return _con[0];
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con;
	};

C++【STL】之priority_queue学习，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正！

茉莉蜜茶v
关注
专栏目录
【C++】STL中priority_queue（优先队列）
qq_43730185的博客
05-21 929
1.头文件 #include<queue> 2.定义 1.priority_queue<Type, Container, Functional> Type是数据类型，Container是容器类型（此容器必须是数组实现的容器，比如vector，deque，但不能是list。STL中默认为vector）Functional是比较方式，当使用自定义比较方式时需要传入这三个参数...
C++STL容器之priority_queue
Jerry_qbw的博客
07-26 1382
观察这两张图片，他们都是二叉树，若果观察的仔细，能看出他们是完全二叉树。左图中，根节点是所有元素中最大的，右图中则恰好相反。左图每个节点都比他的左右子节点大，有图每个节点都比他的左右子节点小，这就是堆结构。堆是具有下列性质的完全二叉树每个节点的值都大于或等于其左右子节点的值，称为大顶堆，相反则为小顶堆从堆的定义得知，根节点一定是其中最大（小）的一个，较大（小）的节点越靠近根节点（不绝对是这样）优先队列使用的数据结构为二叉堆。...
【转】 STL里的priority_queue用法，有这个东西太好了
weixin_30565327的博客
08-19 186
在STL里有这个priority_queue，实现优先队列的结构。在优先队列中，优先级高的元素先出队列。现在在这里说说用法吧 先看看语法： Syntax: In their implementation in the C++ Standard Template Library, priority queues take three template parameters:12 templ...
C++从入门到起飞之——priority_queue(优先级队列) 全方位剖析！
最新发布
小蜗牛的珍贵百宝箱
10-08 1596
/ 创建一个小顶堆（通过自定义比较器）// 输出10// 输出20return 0;不仅仅局限于存储基本数据类型，也可以存储自定义的类型。要使自定义类型能够被正确排序，必须定义比较运算符。// 定义一个结构体int age;
C++基础（三）——STL优先级队列
weixin_42690036的博客
06-19 1447
STL 优先级队列
STL优先级队列
weixin_33885253的博客
08-22 87
priority_queue 这是一个优先级队列的所有权值概念单向队列queue。在这个队列中。全部元素是按优先级排列的（也能够觉得queue是个按进入队列的先后做为优先级的优先级队列——先进入队列的元素优先权要高于后进入队列的元素）。在计算机操作系统中，优先级队列的使用是相当频繁的，进线程调度都会用到。在STL的详细实现中，priority_queue也是以别的容器作为底部结构。再依据堆...
STL之优先级队列(priority_queue)
761899457@qq.com
07-19 3939
最近在刷算法题的时候遇到了需要使用堆来解决的问题(尤其是TOPk问题)，所以想把这些方法总结一下，防止后面忘记了还得到处找资料。希望能帮助到大家参考链接1参考链接2对通常是一个可以被看做一棵树的数组对象，满足两个条件1，堆中的某个结点的值总是不大于或者不小于其父结点的值2，堆是一颗完全二叉树根结点最大的数叫做大根堆，最小的叫做小根堆。堆排序中建堆的时间复杂度为O(n)在C++STL中没有堆的数据结构，所以借助其中的priority_queue(默认是大根堆)......
c++ STL： priority_queue优先队列
qq_42714490的博客
03-16 385
1. 概述 普通队列queue是一种先进先出的数据结构， priority_queue和queue的区别就在于，在优先队列priority_queue中，元素都被赋予优先级，出队是根据优先级出队，优先级高的先出队。 2. 原型说明 priority_queue优先队列在模板申明带3个参数： priority_queue<Type, Container, Functional>...
【OJ - 堆】找数组中的第K个最大元素（C++ STL - priority_queue）
codewinter的博客
05-31 952
题目难度：中等LeetCode链接：215. 数组中的第K个最大元素题目描述：使用头文件 中的 sort 函数模板，直接排序，找到第k个最大的元素 时间复杂度：因为 sort 底层是快速排序，所以时间复杂度为 O(N∗logN)O(N*logN)O(N∗logN) 空间复杂度：O(1)O(1)O(1) 思路2：建大堆 使用堆排序，建立 n 个元素的大堆，做 k - 1 次删除操作后，此时堆顶元素就是第k个最大的元素因为 C++ 的优先级队列 priority_queue 本质就是堆，所以这道题我没有
STL中priority_queue
03-07
STL 中的 priority_queue priority_queue 是 STL 中的一种容器，可以实现优先级队列的功能。下面，我们将详细介绍 priority_queue 的使用方法和实现原理。 priority_queue 的基本概念 priority_queue 是一种特殊...
c++ 优先队列(priority_queue)
热门推荐
STATICHIT静砸的博客
02-13 2万+
C ++中的优先队列是STL中的派生容器，它仅考虑最高优先级元素。队列遵循FIFO策略，而优先队列根据优先级弹出元素，即，优先级最高的元素首先弹出。 它在某些方面类似于普通队列，但在以下方面有所不同： 在优先队列中，队列中的每个元素都与某个优先级相关联，但是优先级在队列数据结构中不存在。 优先队列中具有最高优先级的元素将被首先删除，而队列遵循FIFO（先进先出）策略，这意味着先插入的元素将被首先删除。 如果存在多个具有相同优先级的元素，则将考虑该元素在队列中的顺序。 注意：优
STL中的priority_queue（优先队列）
YXXXYX的博客
09-01 975
引言 priority_queue 也是一种队列，queue 有的性质和操作它也有（但是没有back操作了），唯一不同就是它可以自动排序； 它的本质是通过堆实现的，在堆排序中会见到它，下面说一下它的用法； 基本内容 头文件#include<queue> 定义priority_queue<Type, Container, Functional> Type就是该队列的数据类型， Container是保存数据的容器类型，且该容器必须由数组实现的，默认情况是vector；Functional
C++ STL学习之【优先级队列】
北 海的博客
05-04 1万+
优先级队列是容器适配器中的一种，常用来进行对数据进行优先级处理，比如优先级高的值在前面，这其实就是初阶数据结构中的堆，它俩本质上是一样东西，底层都是以数组存储的完全二叉树，不过优先级队列中加入了泛型编程的思想，并且属于STL中的一部分
STL库--priority_queue
m0_72674633的博客
05-29 1092
STL库priority_queue详解
STL中的优先级队列
红军不怕远征难，万水千山只等闲
05-12 929
优先级队列（Priority Queue）是一种数据结构，其中每个元素都有一个与之关联的“优先级”。在优先级队列中，元素的排列顺序是根据它们的优先级来确定的，而不是它们进入队列的顺序。通常情况下，优先级最高的元素会最先出队。C++标准库中的容器就是一个典型的优先级队列实现。它是一个拥有权值观念的队列，其元素的排列顺序并不是按照插入顺序，而是根据每个元素所关联的优先级（权值）来确定的。默认情况下，使用操作符对元素进行比较，因此优先级最高的元素将位于队列的顶部。默认情况下，使用。
STL的优先队列
ZZHinclude的博客
01-12 237
priority_queue #include <iostream> #include <queue> using namespace std; //优先队列是用堆实现的 默认是大根堆 int main(int argc, char** argv) { priority_queue<int> heap; //优先队列只能通过Top来读取元素 没有front和back heap.push(10); heap.push(5); cout<<
c++ priority_queue
clutch020的博客
09-03 392
首页 > 编程笔记 > C++笔记 阅读：27,279 C++ priority_queue(STL priority_queue)用法详解 C语言中文网推出辅导班啦，包括「C语言辅导班、C++辅导班、算法/数据结构辅导班」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践 + 永久学习。QQ在线，随时响应！ 不出所料，priority_queue 容器适配器定义了一个元素有序排列的队列。默认队列头部的元素优先级最高。因为它是一个队列，所以只能访问第一个元素，...
STL之优先队列
A.pro的博客
08-18 764
说到队列，我们首先想到就是先进先出，后进后出；那么何为优先队列呢，在优先队列中，元素被赋予优先级，当访问元素时，具有最高级优先级的元素先被访问。即优先队列具有最高级先出的行为特征。这种行为有点像“急诊病人插队”的原理。 STL的优先队列也定义在&lt;queue&gt;里。用priority_queue&lt;int&gt; pque;来声明。这个qpue就是“越小的整数优先级越低的优先队列”。...
C++ STL priority_queue
08-30
C++ STL中的priority_queue是一个优先队列，它是一个使用堆来实现的容器。它可以按照一定的优先级顺序存储元素，并且每次访问队首元素都是访问优先级最高的元素。 在使用priority_queue时，可以通过定义不同的比较函数来指定元素的优先级顺序。默认情况下，对于基本类型，默认是大顶堆，降序队列。也可以通过指定参数来实现小顶堆，升序队列。例如： priority_queue<int, vector<int>, greater<int>> q; //小顶堆，升序队列 priority_queue<int, vector<int>, less<int>> q; //大顶堆，降序队列 在对priority_queue进行操作时，可以使用push()函数向队列中插入元素，使用top()函数获取队首元素，使用pop()函数删除队首元素。 在自定义类型的优先队列中，可以重载运算符>或<来定义优先级。例如，可以重载operator>来定义小顶堆，即优先级较小的元素排在前面。示例代码如下： struct Node{ int x, y; Node(int a=0, int b=0): x(a), y(b) {} }; bool operator> (Node a, Node b){ if(a.x == b.x) return a.y > b.y; return a.x > b.x; } priority_queue<Node, vector<Node>, greater<Node>> q; q.push(Node(rand(), rand())); while(!q.empty()){ cout<<q.top().x<<' '<<q.top().y<<endl; q.pop(); } 总结来说，C++ STL中的priority_queue是一个使用堆实现的优先队列，可以按照指定的优先级顺序存储元素。可以通过定义不同的比较函数或重载运算符来指定优先级规则。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [【总结】C++ 基础数据结构 —— STL之优先队列（priority_queue） 用法详解](https://blog.csdn.net/weixin_44668898/article/details/102132580)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

茉莉蜜茶v

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

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

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

打赏作者

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

抵扣说明：

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

余额充值