目录
一、优先级队列的介绍
一、优先级队列的概念
优先级队列(priority_queue)其实更像是数据类型中的“堆”。优先级队列每次出队的元素是队列中优先级最高的那个元素,而不是队首的元素。这个优先级可以通过元素的大小等进行定义。比如定义元素越大优先级越高,那么每次出队,都是将当前队列中最大的那个元素出队。个人感觉这就是所谓“优先级”的定义。
现在看优先级队列是不是就是“堆”了,如果最大的元素优先级最高,那么每次出队的就是当前队列中最大的元素,那么队列实际就相当于一个大顶堆,每次将堆根节点元素弹出,重新维护大顶堆,就可以实现一个优先级队列。
1. 优先队列是一种容器适配器,根据严格的弱排序标准,它的第一个元素总是它所包含的元素中最大的。
2. 此上下文类似于堆,在堆中可以随时插入元素,并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. 优先队列被实现为容器适配器,容器适配器即将特定容器类封装作为其底层容器类,queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出,其称为优先队列的顶部。
二、优先级队列的定义
template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> > class priority_queue;
第一个模板参数为为class T,代表每个元素的类型.
第二个模板参数为class Container,缺省值为vector<T>,代表存储这些数据的容器,可以是vector,deque等,但不能是list,因为它的内部空间不连续.
第三个模板参数为class Compare,缺省值为less<T>,其中less是个仿函数,是降序排序,既优先级最大的是容器中最大的元素.又叫比较函数.
当然可以升序排序,把less改为greater即可.
less 和 greater使用的前提是建立在这些数据类型是C++基本的数据类型.
定义类型的试例
//不写后面两个参数默认为vector,less
priority_queue<int> pq1;
//建立一个优先级队列(大堆),数据类型是int,利用vector容器实现,less(降序)实现
priority_queue<int, vector<int>, less<int>> pq2;
//建立一个优先级队列(小堆),数据类型是int,利用vector容器实现,greater(降序)实现
priority_queue<int, vector<int>, greater<int>> pq3;
三、基本操作(常见接口的功能)
它的操作与基本队列操作一样,主要有以下接口:
top() :返回元素中第一个元素的引用(优先级最高的元素都会被放到顶部,既第一个元素).
push():插入一个元素,并重新维护堆,无返回值.
pop() :删除优先级最高的元素,并重新维护堆无返回值
size() :返回容器中有效元素的数量,返回队列的大小
empty() :检测容器是否为空.返回“true”或者“false”.
二、优先级队列的模拟实现
一、构造函数的实现
一、模板参数
template<class T,class Container = vector<T>,class Compare = less<T>>
二、成员变量
Container _con;
三、无参的默认构造
priority_queue()
{}
在自己实现了构造函数后,编译器就不会自动实现默认构造,所以这边要自己实现。
二、调整算法
一、向下调整算法
void adjust_down(size_t parent) {
compare com;
size_t child = parent * 2 + 1;
while (child < _con.size()) {
if (child + 1 < _con.size() && com(_con[child] , _con[child + 1])) {
child = child + 1;
}
if (com(_con[parent] , _con[child])) {
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
大概总固体思路是:先根据根节点找到孩子结点,然后判断左右两个孩子结点中的哪个大,默认是孩子结点是左孩子结点,如果右孩子结点比左孩子结点大,那么直接++即可,就是右孩子结点.
然后再判断,如果孩子结点的值大于父节点的值,则交换,并且更新父节点和孩子结点的值.
二、向上调整算法
void adjust_up(size_t child) {
size_t parent = (child - 1) / 2;
while (child > 0) {
compare com;
if (com(_con[parent],_con[child]) ) {
swap(_con[child], _con[parent]);
}
else {
break;
}
child = parent;
parent = (child - 1) / 2;
}
}
大概总固体思路是:先根据孩子节点找到对应的父节点进行比较,满足条件就交换父子节点的值,然后继续向上寻找父节点
三、常见接口的实现
1、push
void push(const T& x) {
_con.push_back(x);
adjust_up(_con.size()-1);
}
直接使用适配器的尾插函数来进行插入,然后用向上调整算法调整位置
2、pop
void pop() {
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
adjust_down(0);
}
先把首尾元素进行交换,然后删除最后一个元素,再进行向下调整
3、top
const T& top() {
return _con[0];
}
返回首元素,也就是堆中的根节点,直接返回容器的首元素就行
4、empty size
bool empty() {
return _con.empty();
}
size_t size() {
return _con.size();
}
这两个都是容器中有的,直接返回容器中对应的函数就可以
四、仿函数的实现
通过我们上面写的向上调整,向下调整算法,发现有一个比较麻烦的地方
就是它其中的每次比较都是大于,既每次都是大顶堆
但是如果我们想要小顶堆怎么办?只能一点一点的改大小于符号 ,很容易就会混和忘记,非常的不方便.
这个时候我们便可以使用仿函数来解决这个问题.这个时候便用到刚开始写的三个模板参数中的第三个参数了.
可以先写两个仿函数,一个用来构造小顶堆,另外的是大顶堆.
template<class T>
class less
{
public:
bool operator()(const T& l, const T& r)
{
return l < r;
}
};
template<class T>
class greater
{
public:
bool operator()(const T& l, const T& r)
{
return l > r;
}
};
这样就可以做到在实例化的时候控制实现的是大堆还是小堆了
全部代码
#pragma once
#include<vector>
using namespace std;
namespace bit {
template<class T>
class Less {
public:
bool operator()(const T& x, const T& y) {
return x < y;
}
};
template<class T>
class Greater {
public:
bool operator()(const T& x, const T& y) {
return x > y;
}
};
template<class T,class Container = vector<T>,class compare = Less<T>>
class priority_queue {
public:
void adjust_up(size_t child) {
size_t parent = (child - 1) / 2;
while (child > 0) {
compare com;
if (com(_con[parent],_con[child]) ) {
swap(_con[child], _con[parent]);
}
else {
break;
}
child = parent;
parent = (child - 1) / 2;
}
}
void adjust_down(size_t parent) {
compare com;
size_t child = parent * 2 + 1;
while (child < _con.size()) {
if (child + 1 < _con.size() && com(_con[child] , _con[child + 1])) {
child = child + 1;
}
if (com(_con[parent] , _con[child])) {
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void push(const T& x) {
_con.push_back(x);
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];
}
bool empty() {
return _con.empty();
}
size_t size() {
return _con.size();
}
private:
Container _con;
};
}