文章目录
- 1. 介绍
- 2. priority_queue的使用
- 3. priority_queue的模拟实现
1. 介绍
英文解释：
也就是说：
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
作图理解：
关于其底层数据结构堆可以参照树、二叉树（C语言版）中==二叉树的顺序结构实现==部分的内容，这里重点讲解priority_queue的使用和其在库中的模拟实现。
2. priority_queue的使用
template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type>> class priority_queue;priority_queue是容器适配器。使用时需实例化其模板参数。
有三个模板参数：
T：表示存储在优先级队列中的元素的类型。Container：表示用于存储元素的底层容器类型。默认情况下，它使用vector<T>，但你可以根据需要指定其他容器类型。Compare：表示用于比较元素优先级的函数对象类型（传参可以用类重载operator()形成的仿函数）。默认情况下，它使用less<typename Container::value_type>，这将使用元素类型的<运算符来进行比较。你也可以提供自定义的比较函数对象。即默认为==大堆==。用法样例：
class mycomparison {bool reverse; public:mycomparison(const bool& revparam = false){reverse = revparam;}bool operator() (const int& lhs, const int& rhs) const{if (reverse) return (lhs > rhs);else return (lhs < rhs);} };int main() {int myints[] = { 10,60,50,20 };std::priority_queue<int> first;std::priority_queue<int> second(myints, myints + 4);std::priority_queue<int, std::vector<int>, std::greater<int> >third(myints, myints + 4);// using mycomparison:typedef std::priority_queue<int, std::vector<int>, mycomparison> mypq_type;mypq_type fourth; // less-than comparisonmypq_type fifth(mycomparison(true)); // greater-than comparisonreturn 0; }说明：
- first 变量是空的 priority_queue 对象，使用默认的 less 比较，是大堆。
- second 变量包含了四个整数，这四个整数由 myints 定义。默认使用 less 比较，所以为大堆，此时堆顶为60。
- third 变量包含四个整数，只不过使用了 greater 比较，变成了小堆，此时堆顶为10。
- fourth 变量是空的 priority_queue 对象，使用自定义的比较方式 mycomparision，此时同样为大堆。
- fifth 变量是空的 priority_queue 对象，使用自定义的比较方式 mycomparision，同时传参 true 构造改变了
operator()的返回值，此时为小堆。注：这里由于 mycomparison 重载了
operator()，所以可以作为仿函数充当形参。具体调用 mycomparison 时的操作，请看模拟实现部分。
接口成员函数
| 函数名称 | 代码 | 功能说明 |
|---|---|---|
| empty | bool empty() const; | 返回 priority_queue 是否为空。 |
| size | size_type size() const; | 返回 priority_queue 中元素个数。 |
| top | const_reference top() const; | 返回堆顶元素的引用。 |
| push | void push (const value_type& val);void push (value_type&& val); | 向 priority_queue 插入一个新元素 val。 |
| pop | void pop(); | 删除堆顶元素。 |
| swap | void swap (priority_queue& x) noexcept; | 用于和另一个容器适配器 x 交换内容。 |
priority_queue的遍历
#include <iostream>
#include <queue>int main()
{int myints[] = { 10,60,50,20,30,100,200 };std::priority_queue<int> myPriorityQueue(myints, myints + sizeof(myints) / sizeof(int));// 使用迭代器遍历优先级队列std::priority_queue<int> tempQueue = myPriorityQueue; // 创建临时队列用于遍历while (!tempQueue.empty()){std::cout << tempQueue.top() << " ";tempQueue.pop();}return 0;
}
运行结果：
说明：
首先将其内容复制到一个临时队列
tempQueue中，使用top函数访问临时队列的顶部元素，将其输出，然后使用pop函数将其从队列中移除。重复这个过程，直到临时队列为空。
3. priority_queue的模拟实现
#pragma once
#include<vector>using namespace std;namespace my_priority_queue
{// 大堆template<class T>struct less{bool operator()(const T& left, const T& right){return left < right;}};// 小堆template<class T>struct greater{bool operator()(const T& left, const T& right){return left > right;}};template <class T, class Container = vector<T>, class Compare = less<T>>class priority_queue{public:priority_queue(){}template <class InputIterator>priority_queue(InputIterator first, InputIterator last):c(first, last){for (int i = (c.size() - 1 - 1) / 2; i >= 0; i--){adjudge_down(i);}}bool empty() const{return c.empty();}size_t size() const{return c.size();}const T& top() const{return c[0];}void push(const T& x){c.push_back(x);adjudge_up(c.size() - 1);}void pop(){swap(c[0], c[c.size() - 1]);c.pop_back();adjudge_down(0);}private:void adjudge_up(size_t child){if (child == 0)return;size_t parent = (child - 1) / 2;while (child > 0){if (comp(c[parent], c[child])){swap(c[parent], c[child]);child = parent;parent = (child - 1) / 2;}else{break;}}}void adjudge_down(size_t parent){size_t child = parent * 2 + 1;while (child < c.size()){if (child + 1 < c.size() && comp(c[child], c[child + 1])){++child;}if (comp(c[parent], c[child])){swap(c[parent], c[child]);parent = child;child = parent * 2 + 1;}else{break;}}}Container c;Compare comp;};
};
