【C++】-- STL容器适配器之priority_queue
目录
一、什么是priority_queue
二、priority_queue的使用
1.priority_queue的构造
2.push( )
3.pop( )
4.size( )
5.empty( )
三、priority_queue模拟实现
1.仿函数
（1）概念
（2）优点
（3）缺点
（4）实现
2.堆的插入删除
3.代码实现
（1）仿函数<
（2）仿函数>
（3）push()
（4）pop()
（5）top()
（6）size()
（7）empty()
4.完整代码段
一、什么是priority_queue
（1）priority_queue即优先级队列，是一种容器适配器，最大元素放在第一个。
（2）底层用堆实现，默认是大堆，因为默认大的优先级高，可随时插入元素，可快速查找最大元素，即优先级队列中第一个元素。
（3）优先级队列元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
（4）底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty( )：检测容器是否为空
size( )：返回容器中有效元素个数
front( )：返回容器中第一个元素的引用
push_back( )：在容器尾部插入元素
pop_back( )：删除容器尾部元素
（5）标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector，堆的物理结构是数组，所以优先级队列也是一个vector。
（6） 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
二、priority_queue的使用
优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。
1.priority_queue的构造
priority_queue有两种构造方式：
（1）构造一个空的优先级队列
explicit priority_queue (const Compare& comp = Compare(),
const Container& ctnr = Container());//构造一个控的优先级队列构造一个空的优先级队列pq1：
#include
#include//队列
#include//数组
#include//比较符号，less 或 greater
using namespace std;
int main()
{
priority_queue pq1;//构造一个空的优先级队列
pq1.push(3);//向优先级队列中插入元素
pq1.push(1);
pq1.push(6);
pq1.push(12);
pq1.push(7);
while (!pq1.empty())
{
cout << pq1.top() << endl;
pq1.pop();
}
} 
（2）用迭代器区间构造一个优先级队列
template
priority_queue (InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Container& ctnr = Container());//用first和last之间的元素构造优先级队列 使用数组的迭代器区间构造一个优先级队列：
vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
priority_queue pq2(v.begin(), v.end()) ;//用v的迭代器区间构造pq2 以上都构造的是大堆，如何构造一个小堆呢？
可以使用如下模板构造：T是元素类型，Container 指定容器，Compare是元素比较方式，大于还是小于，默认为大于less，即大堆，如果想改成小堆，就用greater。
template ,
class Compare = less > class priority_queue; value_type被typedef为T，编译器编译的时候是没有vecto的，因为vector没有被实例化，所以编译器编译的时候不知道Container是vector，不知道value_type类型。
构造一个小堆：
priority_queue,greater::value_type>> pq4;
pq4.push(20);
pq4.push(2);
pq4.push(8);
pq4.push(5);
while (!pq4.empty())
{
cout << pq4.top() << endl;
pq4.pop();
} 
2.push( )
向优先级队列中插入元素
void push (const value_type& val);//向优先级队列中插入元素向pq3中插入元素：
priority_queue pq3;
pq3.push(6);//向优先级队列中插入元素
pq3.push(3);
pq3.push(9);
pq3.push(8); 3.pop( )
删除优先级队列第一个元素
void pop();//删除优先级队列第一个元素删除pq3的第一个元素：
pq3.pop();//删除优先级队列第一个元素4.size( )
返回优先级队列的元素个数
size_type size() const;//返回优先级队列的元素个数返回pq3的元素个数
cout << pq3.size() << endl;//返回pq3的元素个数
5.empty( )
判断优先级队列是否为空
bool empty() const;//判断优先级队列是否为空判断pq3是否为空
cout << pq3.empty() << endl;
三、priority_queue模拟实现
priority_queue底层用堆实现，priority_queue的模拟实现只需要对堆进行封装即可。
1.仿函数
priority_queue默认是大堆，那么该如何实现小堆呢？需要先了解仿函数。
（1）概念
仿函数让一个类的使用看上去像个函数。仿函数是在类中实现了一个operator( )，是一个类的对象，这个类就有了类似函数的行为，所以这个类就是一个仿函数类，目的是为了让函数拥有类的性质。
这个类的对象即仿函数，可以当作一般函数去用，只不过仿函数的功能是在一个类中的运算符operator()中实现的，使用的时候把函数作为参进行传递即可。
（2）优点
① 仿函数比函数指针的执行速度快，函数指针通过地址调用，而仿函数是对运算符operator进行自定义来提高调用的效率。
② 仿函数比一般函数灵活，可以同时拥有两个不同的状态实体，一般函数不具备此种功能。
③ 仿函数可以作为模板参数使用，因为每个仿函数都拥有自己的类型。
（3）缺点
① 需要单独实现一个类。
② 定义形式比较复杂。
（4）实现
先看如下函数isLess，它实现了<的比较
#include
bool isLess(int l, int r)
{
return l < r;
}
int main()
{
cout << isLess(1, 3) << endl;
} 如果在一个类里，实现同样功能，Less这个类就变成了仿函数类，它的对象就是一个仿函数
struct less
{
bool operator()(int l, int r)
{
return l < r;
}
};这个类还可以再完善一下，使用类模板来支持不同类型的数据使用<比较大小
template
struct less
{
bool operator()(const T& l, const T& r)
{
return l < r;//<的比较
}
}; 同样，>的仿函数类也可以实现了：
template
struct greater
{
bool operator()(const T& l, const T& r)
{
return l > r;//>的比较
}
}; 如何使用仿函数呢？
int main()
{
less lessInt;//定义一个仿函数类对象，参数类型指定为int
std::cout << lessInt(1, 3) << std::endl;//对仿函数的调用等价于std::cout << lessInt.operator()(1, 3) << std::endl;
} priority_queue模板中的less替换成greater就可以实现>的比较了：
template ,
class Compare = greater > class priority_queue; 2.堆的插入删除
要对priority_queue插入删除，就是在堆上插入删除，堆在物理上是数组，在逻辑上是一颗完全二叉树。根据【数据结构】堆-C语言版一文回忆一下堆的插入删除相关知识
（1）堆的插入（先插入，再向上调整）
（2）堆的删除（先交换，然后删除，再向下调整）
3.代码实现
priority_queue类默认的Container是vector，是自定义类型。因此priority_queue的构造函数、拷贝构造函数、赋值运算符重载函数、析构函数都不用写，会调vector的默认构造函数、拷贝构造函数、赋值运算符重载函数、析构函数。只需要实现7个函数：仿函数<、仿函数>、push、pop、top、size、empty。
（1）仿函数<
template
struct less
{
bool operator()(const T& l, const T& r)
{
return l < r;
}
}; （2）仿函数>
template
struct greater
{
bool operator()(const T& l, const T& r)
{
return l > r;
}
}; （3）push()
template,class Compare = delia::less>//指定Compare方式是less，按<比较
class priority_queue
{
public:
//向上调整算法
void AdjustUp(size_t child)
{
Compare com;//定义仿函数类对象
size_t parent = (child - 1) / 2;//找父亲的位置
while (child > 0)
{
//if (_con[parent] < _con[child])//父亲比孩子小，孩子就要往上提
if (com(_con[parent] , _con[child]))//使用仿函数比较
{
swap(_con[parent], _con[child]);//交换父亲和孩子
child = parent;//父亲变孩子
parent = (child - 1) / 2;//重新计算新孩子的父亲位置
}
else
{
//父亲>=孩子就不用动
break;
}
}
}
//插入
void push(const T& x)
{
_con.push_back(x);//尾插到堆
AdjustUp(_con.size() - 1);//向上调整
}
private:
Container _con;
}; （4）pop()
//向下调整算法
void AdjustDown(size_t parent)
{
Compare com;//定义仿函数类对象
size_t child = 2 * parent + 1;//找孩子位置
while (child < _con.size())
{
//找大孩子
if (child + 1 < _con.size() && _con[child+1] > _con[child])
{
child++;
}
//if(_con[parent] < _con[child])父亲比孩子小，父亲就要往下挪
if (com(_con[parent], _con[child]))//使用仿函数比较
{
swap(_con[parent], _con[child]);//交换父亲和孩子
parent = child;//孩子变父亲
child = parent * 2 + 1;//重新计算孩子的位置
}
else
{
break;
}
}
}
//删除
void pop()
{
swap(_con[0], _con[_con.size() - 1]);//交换堆顶元素和堆尾元素
_con.pop_back();//删除堆顶元素
AdjustDown(0);//向下调整算法
}（5）top()
//返回priority_queue第一个元素，即堆顶元素
T top()
{
return _con[0];
}（6）size()
//求priority_queue队列中元素个数
size_t size()
{
return _con.size();
}（7）empty()
//判断priority_queue是否为空
bool empty()
{
return _con.empty();
}4.完整代码段
018-priority_queue.h
#pragma once
#include
using namespace std;
namespace delia
{
template
struct less
{
bool operator()(const T& l, const T& r)
{
return l < r;
}
};
template
struct greater
{
bool operator()(const T& l, const T& r)
{
return l > r;
}
};
template,class Compare = std::less>
class priority_queue
{
public:
//Container默认是vector，自定义类型
//构造函数、拷贝构造函数、赋值运算符重载函数、析构函数都不用写，会调用vector的构造函数和析构函数等
//向上调整算法
void AdjustUp(size_t child)
{
Compare com;//定义仿函数类对象
size_t parent = (child - 1) / 2;//找父亲的位置
while (child > 0)
{
//if (_con[parent] < _con[child])//父亲比孩子小，孩子就要往上提
if (com(_con[parent] , _con[child]))//使用仿函数比较
{
swap(_con[parent], _con[child]);//交换父亲和孩子
child = parent;//父亲变孩子
parent = (child - 1) / 2;//重新计算新孩子的父亲位置
}
else
{
//父亲>=孩子就不用动
break;
}
}
}
//插入
void push(const T& x)
{
_con.push_back(x);//尾插到堆
AdjustUp(_con.size() - 1);//向上调整
}
//向下调整算法
void AdjustDown(size_t parent)
{
Compare com;//定义仿函数类对象
size_t child = 2 * parent + 1;//找孩子位置
while (child < _con.size())
{
//找大孩子
if (child + 1 < _con.size() && _con[child+1] > _con[child])
{
child++;
}
//if(_con[parent] < _con[child])父亲比孩子小，父亲就要往下挪
if (com(_con[parent], _con[child]))//使用仿函数比较
{
swap(_con[parent], _con[child]);//交换父亲和孩子
parent = child;//孩子变父亲
child = parent * 2 + 1;//重新计算孩子的位置
}
else
{
break;
}
}
}
//删除
void pop()
{
swap(_con[0], _con[_con.size() - 1]);//交换堆顶元素和堆尾元素
_con.pop_back();//删除堆顶元素
AdjustDown(0);//向下调整算法
}
//返回priority_queue第一个元素，即堆顶元素
T top()
{
return _con[0];
}
//求priority_queue队列中元素个数
size_t size()
{
return _con.size();
}
//判断priority_queue是否为空
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
} 018-test.cpp
#include "018-priority_queue.h"
#include
void test_priority_queue()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
std::cout << "priority_queue:" << std::endl;
while (!pq.empty())
{
std::cout << pq.top() << std::endl;
pq.pop();
}
std::cout << std::endl;
}
void test_priority_queue_push()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
pq.push(83);
std::cout << "push:" << std::endl;
while (!pq.empty())
{
std::cout << pq.top() << std::endl;
pq.pop();
}
std::cout << std::endl;
}
void test_priority_queue_pop()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
std::cout << "pop:" << std::endl;
pq.pop();
while (!pq.empty())
{
std::cout << pq.top() << std::endl;
pq.pop();
}
std::cout << std::endl;
}
void test_priority_queue_top()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
std::cout << "top:" << std::endl;
std::cout << pq.top() << std::endl;
std::cout << std::endl;
}
void test_priority_queue_size()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
std::cout << "size:" << std::endl;
std::cout << pq.size() << std::endl;
std::cout << std::endl;
}
void test_priority_queue_empty()
{
delia::priority_queue pq;
pq.push(9);
pq.push(26);
pq.push(31);
pq.push(3);
pq.push(11);
pq.push(1);
pq.push(5);
pq.push(39);
pq.push(23);
pq.push(18);
std::cout << "empty:" << std::endl;
std::cout << pq.empty() << std::endl;
std::cout << std::endl;
}
int main()
{
test_priority_queue();
test_priority_queue_push();
test_priority_queue_pop();
test_priority_queue_top();
test_priority_queue_size();
test_priority_queue_empty();
return 0;
} 运行结果如下
