【C++】priority_queue使用与模拟实现

认识priority_queue

1、priority_queue(优先级队列)是一种容器适配器，底层是一个完全二叉树的大堆（堆总是一颗完全二叉树，根结点最大的堆叫做大堆；根结点最小的堆叫做小堆），头文件在queue中，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。不按照先进先出，优先级高的先出，默认数字大的优先级高。

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

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

4、底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

  • empty()：检测容器是否为空
  • size()：返回容器中有效元素个数
  • front()：返回容器中第一个元素的引用
  • push_back()：在容器尾部插入元素
  • pop_back()：删除容器尾部元素

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

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

priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

容器适配器都是不支持遍历的，不支持范围for。

函数声明接口说明
priority_queue()/priority_queue(first, last)构造一个空的优先级队列
empty( )检测优先级队列是否为空，是返回true，否则返回 false
top( )返回优先级队列中最大(最小元素)，即堆顶元素
push(val)在优先级队列中插入元素val
pop()删除优先级队列中最大(最小)元素，即堆顶元素

库中priority_queue的定义：

template <class T, class Container = vector<T>,  class Compare = less<typename Container::value_type> > class priority_queue;

默认使用vector作为底层容器。

使用：

#include <queue>
#include <iostream>
using namespace std;
int main()
{priority_queue<int> pq;//默认数字大的优先级高，即默认大堆//也可以通过指定模板参数从而让数字小的优先级高,即变成小堆//priority_queue<int, vector<int>, greater<int>> pq;for (int i = 0; i < 10; i++){pq.push(i);}cout << pq.size() << endl;//输出队列中元素个数 10while (!pq.empty())//判断是否为空{cout << pq.top() << " ";//队头的元素pq.pop();//队头元素出队列}//输出9 8 7 6 5 4 3 2 1 0//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9return 0;
}

如果想要使优先级队列中小的优先级更高，则可以借助仿函数**greater<int>**，包含在头文件functional中。

priority_queue<int, vector<int>, greater<int>> pq;

仿函数

仿函数都需要重载一个()。仿函数就是重载了一个()，让对象可以像函数一样去使用。

我们来定义一个仿函数：

template<class T>
struct Less {bool operator()(const T& l1, const T& l2){return l1 < l2;}
};

在Less类中我们重载了()，使其成为了能够比较大小的一个运算符：

#include <iostream>
using namespace std;
template<class T>
struct Less {bool operator()(const T& l1, const T& l2){return l1 < l2;}
};
int main()
{Less<int> LessFunc;cout << LessFunc(2, 3) << endl;//输出1return 0;
}

如果只看cout << LessFunc(2, 3) << endl，我们可能会认为LessFunc是一个函数或者函数指针，但是LessFunc是个Less<int>类型的对象，所以我们叫做仿函数。对象可以像函数一样去使用，本质是调用了operator()，运算符重载。

仿函数是为了解决函数指针void(*ptr)()太复杂的问题。

greater<int>和less<int>都是库里面写好的，priority_queue默认使用的是less<int>。

堆算法

**堆的底层是一个数组，**我们先认识两种堆的算法：向上调整法和向下调整法。

向上调整法

向上调整法基本思想（以大堆为例）：

将插入结点作为目标结点，将目标结点和其父结点比较，如果目标结点的值比父结点的值大，则交换目标结点和父结点的位置，交换之后目标结点就变为父结点，然后继续向上调整；如果目标结点的值比父结点的值小，停止调整说明此时该完全二叉树已经是大堆了。

例：我们在下面的大堆最后位置插入数据100，通过向上调整法调整之后使其仍然是一个大堆：

image-20230705164654763

此时目标结点就是刚插入的结点，值为100，比父结点值大，所以要将目标结点和父结点交换位置：

image-20230705164828199

继续比较并调整，此时目标结点值为100，比父结点值大，交换两者位置：

image-20230705164919608

此时调整完成，该树已经调整成大堆了。

向上调整代码如下：

//大堆的向上调整法
void adjust_up(vector<int>& v, int child)
{//找出父结点int parent = (child - 1) / 2;//当child大于0时一直循环，当child = 0时说明已经调整完while (child > 0){if (v[parent] < v[child])//当parent值小于child值时调整{swap(v[parent], v[child]);//交换父结点和子结点位置child = parent;//此时child等于parentparent = (child - 1) / 2;//重新求父结点}//此时说明已经是大堆了，不需要调整了else{break;}}
}

向下调整法

使用堆的向下调整算法有一个前提条件：待向下调整的结点的左子树和右子树都必须为大堆。

向下调整法基本思想（以大堆为例）：

将目标结点与自己较大的子结点进行比较，如果目标结点的值比它较大的子结点的值小，则交换目标结点与其较大的子结点的位置，并将较大子结点当作新的目标结点继续向下调整；如果目标结点的值比它较大子结点的值大，则停止向下调整，说明该树已经是大堆。

例：使用向下调整法将下面的完全二叉树调整成大堆（根结点的左右子树已经是大堆）。

image-20230705171138567

通过上图我们可以看出其根结点小于右孩子，所以将根结点和右孩子交换：

image-20230705171354442

经过上次交换之后，值为60的结点还是小于自己的右孩子，再交换：

image-20230705171502735

此时已经调整为大堆。

向下调整法的代码：

//大堆的向下调整
void adjust_down(vector<int>& v,int n,int parent)
{int child = (parent * 2) + 1;//求出左孩子while (child < n){//找到最大孩子结点且保证child合法if (child + 1 < n && v[child + 1] > v[child]){child++;}if (v[child] > v[parent])//判断孩子结点是否大于父结点{swap(v[child], v[parent]);//交换结点位置parent = child;//重新赋值child = (parent * 2) + 1;//重新求出孩子结点}//已经是大堆else{break;}}
}

模拟实现priority_queue

优先级队列默认给的容器vector，大堆，数字大的优先级高。

优先级队列底层实际上就是堆结构，通过堆算法实现优先级，堆的底层是一个数组。

我们知道了堆算法的实现，那么priority_queue的模拟实现就变得简单了，其他的操作直接复用容器的函数就可以实现，模拟实现代码如下：

namespace Niu {template<class T,class Container = vector<T>>class priority_queue {public://大堆的向上调整法void adjust_up(int child){//找出父结点int parent = (child - 1) / 2;//当child大于0时一直循环，当child = 0时说明已经调整完while (child > 0){if (_con[parent] < _con[child])//当parent值小于child值时调整{swap(_con[parent], _con[child]);//交换父结点和子结点位置child = parent;//此时child等于parentparent = (child - 1) / 2;//重新求父结点}//此时说明已经是大堆了，不需要调整了else{break;}}}//大堆的向下调整void adjust_down(int parent){int child = (parent * 2) + 1;//求出左孩子while (child < _con.size()){//找到最大孩子结点且保证child合法if (child + 1 < _con.size() && _con[child + 1] > _con[child]){child++;}if (_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;};
}

测试：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include "priority_queue.h"
int main()
{Niu::priority_queue<int> pq;//默认数字大的优先级高，即默认大堆for (int i = 0; i < 10; i++){pq.push(i);}cout << pq.size() << endl;//输出队列中元素个数 10while (!pq.empty())//判断是否为空{cout << pq.top() << " ";//队头的元素pq.pop();//队头元素出队列}//输出9 8 7 6 5 4 3 2 1 0//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9return 0;
}

数值大的优先级高，priority_queue是一个适配器，当我们将底层模板参数更改为deque<T>仍然能运行。

template<class T,class Container = deque<T>>

那此时默认的是数值大的优先级高，如果想让数值小的优先级高可以通过仿函数实现。

注意仿函数定义时>是小堆，<是大堆，定义仿函数的时候运算符要和类名保持一致。

在下面的代码中定义了两个仿函数，同时将向上调整法和向下调整法中的大小比较通过仿函数实现（还可以传一个匿名对象调用仿函数）：

namespace Niu {//定义大堆template<class T>struct less {bool operator()(const T& a, const T& b){return a < b;}};//定义小堆template<class T>struct greater {bool operator()(const T& a, const T& b){return a > b;}};template<class T,class Container = vector<T>,class Compare = less<T>>class priority_queue {public://大堆的向上调整法void adjust_up(int child){Compare com; //此时我们可以使用重载的运算符//找出父结点int parent = (child - 1) / 2;//当child大于0时一直循环，当child = 0时说明已经调整完while (child > 0){//if (_con[parent] < _con[child])//当parent值小于child值时调整if(com(_con[parent],_con[child])){swap(_con[parent], _con[child]);//交换父结点和子结点位置child = parent;//此时child等于parentparent = (child - 1) / 2;//重新求父结点}//此时说明已经是大堆了，不需要调整了else{break;}}}//大堆的向下调整void adjust_down(int parent){Compare com; //此时我们可以使用重载的运算符int child = (parent * 2) + 1;//求出左孩子while (child < _con.size()){//找到最大孩子结点且保证child合法//if (child + 1 < _con.size() && _con[child + 1] > _con[child])if (child + 1 < _con.size() && com(_con[child], _con[child + 1])){child++;}//if ( _con[parent] < _con[child])if (com(_con[parent], _con[child]))//判断孩子结点是否大于父结点//还可以传一个匿名对象调用if (com()(_con[parent] , _con[child])){swap(_con[child], _con[parent]);//交换结点位置parent = child;//重新赋值child = (parent * 2) + 1;//重新求出孩子结点}//已经是大堆else{break;}}}private:Container _con;};
}

测试：

int main()
{	//通过指定模板参数从而让数字小的优先级高,即变成小堆Niu::priority_queue<int, vector<int>, greater<int>> pq;for (int i = 0; i < 10; i++){pq.push(i);}cout << pq.size() << endl;//输出队列中元素个数 10while (!pq.empty())//判断是否为空{cout << pq.top() << " ";//队头的元素pq.pop();//队头元素出队列}//输出0 1 2 3 4 5 6 7 8 9return 0;
}

不是内置类型也可以用模板参数比较大小，但是我们要重载>和<运算符，方便在调用仿函数时调用，如下面的日期类代码：

class Date
{public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}friend ostream& operator<<(ostream& _cout, const Date& d){_cout << d._year << "-" << d._month << "-" << d._day;return _cout;}private:int _year;int _month;int _day;
};
void test_priority_queue2()
{// 大堆，需要用户在自定义类型中提供<的重载priority_queue<Date> q1;q1.push(Date(2018, 10, 29));q1.push(Date(2018, 10, 28));q1.push(Date(2018, 10, 30));cout << q1.top() << endl;
}

我们实现了>和<运算符重载，这样在自定义类型的优先级队列中，当我们push时，在push函数中调用adjust_up函数，而在adjust_up函数中有仿函数的使用，仿函数中有类型比较，整个过程如下图：

image-20230705204240242

那此时如果我们想比较两个Date*类型所指向的日期大小我们应该怎么办呢？

Date*可以比较大小，但是不是我们想要的，new出来的地址没有先大先小的概念，完全没有规律。所以我们也可以通过仿函数来比较。

实现两个日期类指针的仿函数（注意要在日期类下面定义）：

class PDateLess{
public:bool operator()(const Date* p1, const Date* p2){return *p1 < *p2;}
};
class PDateGreater{
public:bool operator()(const Date* p1, const Date* p2){return *p1 > *p2;}
};

测试：

void test_priority_queue2()
{// 大堆，需要用户在自定义类型中提供<的重载priority_queue<Date> q1;q1.push(Date(2018, 10, 29));q1.push(Date(2018, 10, 28));q1.push(Date(2018, 10, 30));cout << q1.top() << endl;//输出2018-10-30//priority_queue<Date*,vector<Date*>,PDateLess> q2;//大堆priority_queue<Date*, vector<Date*>, PDateGreater> q2;//小堆q2.push(new Date(2018, 10, 29));q2.push(new Date(2018, 10, 28));q2.push(new Date(2018, 10, 30));cout << *(q2.top()) << endl;//返回值为日期指针类型，所以要解引用//输出2018-10-28
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/20960.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

dSYM文件是什么 ?

dSYM文件是什么 ?

Overview 概述 dSYM的全称是debug symbol, 所以dSYM文件就是debug symbol (dSYM) file, dSYM文件中的每个 debug symbol, 对应了一个关系, 这个关系一端是源代码里真实的符号(类名称、全局变量以及方法和函数名称), 另一端则是其定义的文件号和行号. Apple Documentation 苹果…
阅读更多...
Java设计模式之结构型-享元模式（UML类图+案例分析）

Java设计模式之结构型-享元模式（UML类图+案例分析）

目录 一、基本概念 二、UML类图 三、角色设计 四、案例分析 1、基本实现 2、游戏角色 五、总结 一、基本概念 享元模式是一种结构型设计模式&#xff0c;主要用于减少创建大量相似对象所占用的内存&#xff0c;它通过共享技术来有效支持大量细粒度的对象。 二、UML类图…
阅读更多...
即视角｜出海资本热土——印尼市场洞察（上）

即视角｜出海资本热土——印尼市场洞察（上）

即视角Insight 共享即构新洞察&#xff0c;共建行业新动能——ZEGO即构科技基于音视频技术领域的多年深耕&#xff0c;综合面向各行业的服务经验&#xff0c;在【即视角】栏目发布即构对行业的洞察。 此前我们根据即构对出海客户的服务经验&#xff0c;输出了文章《即视角&am…
阅读更多...
【数据结构】二叉树的前中后序遍历(C语言)

【数据结构】二叉树的前中后序遍历(C语言)

文章目录 什么是二叉树树相关的概念树的表示形式特殊的二叉树如何创造出一棵二叉树二叉树的遍历先序遍历(前序遍历)中序遍历后序遍历 总结 什么是二叉树 [二叉树] 顾名思义就是有两个分支节点的树&#xff0c;不仅如此&#xff0c;除了叶子外的所有节点都具有两个分支节点&…
阅读更多...
RiProV2主题一级分类显示包含子分类的数量Ritheme主题美化WordPress美化类似的步骤

RiProV2主题一级分类显示包含子分类的数量Ritheme主题美化WordPress美化类似的步骤

美化-RiProV2主题一级分类显示包含子分类的数量 WordPress主题一级分类页面显示包含子分类的数量 一级分类显示子分类相加的数量 原主题配置项 原来的RiProV2主题，虽然有个配置用来显示分类下的数量。 但是该数量有个问题，就是一级分类的数量显示不包含该一级分类下二级…
阅读更多...
使用React的函数式组件实现一个具有过渡变化、刻度切换、点击高亮的柱状图DIY组件

使用React的函数式组件实现一个具有过渡变化、刻度切换、点击高亮的柱状图DIY组件

本想使用业界大佬们开源的各种图表库&#xff08;如&#xff1a;ECharts、G2可视化引擎、BizCharts ...&#xff09;&#xff0c;但是有的需求不仅要求有过渡变化&#xff0c;还要点击某个图高亮同时发送HTTP请求数据等功能&#xff0c;着实不知道怎么把canvas或svg绘制的图表弄…
阅读更多...
【OJ比赛日历】快周末了，不来一场比赛吗？ #07.15-07.21 #7场

【OJ比赛日历】快周末了，不来一场比赛吗？ #07.15-07.21 #7场

CompHub[1] 实时聚合多平台的数据类(Kaggle、天池…)和OJ类(Leetcode、牛客…&#xff09;比赛。本账号会推送最新的比赛消息&#xff0c;欢迎关注&#xff01; 以下信息仅供参考&#xff0c;以比赛官网为准 目录 2023-07-15&#xff08;周六&#xff09; #3场比赛2023-07-16…
阅读更多...
链上衍生品协议 ProsperEx：探索 RWA 叙事，打造 DeFi 变异黑马

链上衍生品协议 ProsperEx：探索 RWA 叙事，打造 DeFi 变异黑马

“ProsperEx 本身背靠着具备潜力的链上衍生品赛道&#xff0c;同时也是 RWA 领域早期的布局者之一&#xff0c;其有望成为 Web2 世界与 Web3 世界的早期连接点&#xff0c;并具备广泛且规模性捕获用户的能力。” 从2020年DeFi之夏链上世界迎来了爆发后&#xff0c;链上衍生品赛…
阅读更多...
Gateway网关组件(在Spring Cloud整合Gateway(idea19版本))

Gateway网关组件(在Spring Cloud整合Gateway(idea19版本))

Spring Cloud Gateway官网:Spring Cloud Gateway 局域网中就有网关这个概念&#xff0c;局域网接收数据或发送数据都要通过网关&#xff0c;比如使用VMware虚拟机软件搭建虚拟机集群的时候&#xff0c;往往我们需要选择IP段中的⼀个IP作为网关地址,网关可以对请求进行控制,提升…
阅读更多...
JAVA+Selenium最简单的处理登录弹窗的方式

JAVA+Selenium最简单的处理登录弹窗的方式

在做自动化测试遇到需要处理登录弹窗情况&#xff0c;例如我的用户名为admin, 密码为admin, 那么想要登录http://10.10.168.1, 只需要使用以下链接访问即可立即登录, 并免除弹窗: http://账号:密码网址
阅读更多...
Layui 简单介绍及入门

Layui 简单介绍及入门

目录 一.Layui &#xff08;国产品牌&#xff09; 1.1 Layui是什么 二.比较layui和easyui&#xff0c;bootstrap的区别 2.1 layui和bootstrap的对比 2.2 layui和easyui对比 三.Layui入门 四.案例 一.Layui &#xff08;国产品牌&#xff09; 1.1 Layui是什么 用我的话来…
阅读更多...
MySQL每日一练：多表查询——连接查询、子查询

MySQL每日一练：多表查询——连接查询、子查询

目录 1、首先创建员工表emp和部门表dept&#xff1a; dept表&#xff1a; emp表&#xff1a; 2、插入数据&#xff1a; dept表&#xff1a; emp表&#xff1a; 3、 按条件查找 1、首先创建员工表emp和部门表dept&#xff1a; dept表&#xff1a; create table dept (…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023