C++初阶 | [十一] priority_queue 优先级队列

摘要：priority_queue 优先级队列的使用和模拟实现，仿函数

前言——优先级队列介绍： 

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
   empty()：检测容器是否为空；
   size()：返回容器中有效元素个数；
   front()：返回容器中第一个元素的引用；
   push_back()：在容器尾部插入元素；
   pop_back()：删除容器尾部元素。
5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap和 pop_heap来自动完成此操作。

---

1. priority_queue 的使用示例

头文件：#include<queue> 

查看文档：cplusplus.com/reference/queue/priority_queue/
通过查看文档可知，priority_queue 默认用 vector 作为容器。priority_queue 类似于 heap，底层实现要求支持用 [index] 的方式访问，所以对于 priority_queue 也可以用 deque 作为容器，然而对于数据量较大的情况，deque 通过下标访问的效率不及 vector，因此 deque 更适合用于 list 和 stack，有关这个问题的理由在讲 stack 和 queue 的文章中已经说明。

下面通过一道题来感受 priority_queue 使用：
215. 数组中的第K个最大元素 - 力扣（LeetCode）（ps.这道题用快排的方式解会更好）
代码示例：

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        std::priority_queue<int> q(nums.begin(),nums.end());
        int tmp = k;
        while(--tmp)
        {
            q.pop();
        }
        return q.top();
    }
};

---

接下来，本文将讲解 priority_queue 的模拟实现。 

2. priority_queue 的模拟实现

首先，我们还是将自己的模拟实现封装在一个命名空间里，以示区分。

结构如下：

namespace Btl
{
	template <class T, class Container = std::vector<T>>
	class priority_queue
	{
	private:
		Container c;
	};

};

1）top()、empty() 、size()

		bool empty() const
		{
			return c.empty();
		}

		size_t size() const
		{
			return c.size();
		}

		const T& top() const
		{
			return c.front();
		}

2）push()

这里需要向上调整，具体内容参考 “数据结构” 专栏关于 “堆” 的讲解。

不重要的补充说明：（parent节点的下标与child节点的下标的关系，注解：以下英文均指代节点下标）
leftchild = parent * 2 + 1 ;   → parent = ( leftchild - 1 ) / 2
rightchild = parent * 2 + 2 ;  → parent = ( rightchild - 2 ) / 2 ; 
∵ ( rightchild - 2 ) / 2 为整数
∴ 根据除法取整的原则，则有 ( rightchild - 2 ) / 2 = ( rightchild - 2 ) / 2 + 1 /2 =  ( rightchild - 2 + 1 ) / 2 =  ( rightchild - 1 ) / 2
∴ parent = ( child - 1 ) / 2

代码示例： 

        void adjustup(const size_t index)
		{
			size_t child = index;
			size_t parent = (child - 1) / 2;
			while (child && parent < child)// → Compare(parent, child)
			{
				std::swap(c[child], c[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
		}

		void push(const T& x)
		{
			c.push_back(x);
			adjustup(c.size() - 1);
		}

3）pop()

交换头尾数据之后，再向下调整。

代码示例：

		void adjustudown()
		{
			size_t parent = 0;
			size_t child = parent * 2 + 1;

			while (child < size() && c[parent] < c[child])//当其parent节点存在叶结点且该子节点大于其parent节点时执行循环体
			{
				if (child + 1 < size() && c[child] < c[child + 1])//如果右子节点存在则比较两子节点得出数据较大的子节点
					++child;
				std::swap(c[parent], c[child]);
				parent = child;
				child = parent * 2 + 1;
			}

		}

		void pop()
		{
			std::swap(c[0], c[size() - 1]);
			c.pop_back();
			adjustudown();
		}

---

3.仿函数：重载 operator()

示例：

如上图的 less 类即为一个仿函数，上图中的 _less 本质上是一个对象，但是可以像函数一样去使用。仿函数在功能上是为了替代函数指针。函数指针的格式：函数返回类型 (*函数指针变量名)（函数参数，函数参数……） 

1）priority_queue 的模拟实现优化

基于仿函数的应用，上述 priority_queue 的模拟实现可以优化。
首先，对于堆来说，向下调整和向上调整比较的规则决定了是大堆还是小堆。对于大堆来说，如果 parent < child 则调整它；如果 parent > child 则调整它，对于大堆和小堆来说不过一个大小号的转变，因此对于大小的比较上，我们可以替换成仿函数。
则，我们将 priority_queue 的结构修改成如下代码：

namespace Btl
{
	template<class T>
	class less
	{
	public:
		bool operator()(const T& left, const T& right)
		{
			return left < right;
		}
	};

	template <class T, class Container = std::vector<T>, class Compare = less<T> >
	class priority_queue
	{
	private:
		Container c;
		Compare comp;
	};

};

对于向下调整和向上调整的函数我们也进行相应的优化：

		void adjustup(const size_t index)
		{
			size_t child = index;
			size_t parent = (child - 1) / 2;
			while (child && comp(c[parent], c[child]))//parent < child → Compare(parent, child)
			{
				std::swap(c[child], c[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
		}

		
		void adjustudown()
		{
			size_t parent = 0;
			size_t child = parent * 2 + 1;

			while (child < size() && comp(c[parent], c[child]))//当其parent节点存在叶结点且该子结点大于其parent节点时执行循环体
				//c[parent] < c[child] → comp(c[parent], c[child])
			{
				if (child + 1 < size() && comp(c[child], c[child + 1]))//c[child] < c[child + 1]  
					++child;
				std::swap(c[parent], c[child]);
				parent = child;
				child = parent * 2 + 1;
			}

		}

注意：区分类模板参数和函数模板参数

补充：迭代器区间初始化

思路：复用容器的迭代器区间初始化，再向下调整建堆。

2）仿函数用法二：针对自定义类型设定个性化比较规则

对于自定义类型：

priority_queue<Date*> （队列中存储的数据类型是指针，但当我本质上是要比较指针所指向的日期大小时）可以通过仿函数设定比较规则 → priority_queue<Date*t,vecotr<Date*>,PDate> q1;（PDate是实现的一个仿函数类型）

---

END