STL之priority_queue的使用及其模拟实现+仿函数

1.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来自动完成此操作。

2.priority_queue的使用

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

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

【注意】

1. 默认情况下，priority_queue是大堆
2. 如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。

#include 
#include 
#include  // greater算法的头文件
void TestPriorityQueue()
{
	// 默认情况下，创建的是大堆，其底层按照小于号比较
	vector v{ 3,2,7,6,0,4,1,9,8,5 };
	priority_queue q1;
	for (auto& e : v)
		q1.push(e);
	cout << q1.top() << endl;
	// 如果要创建小堆，将第三个模板参数换成greater比较方式
	priority_queue, greater> q2(v.begin(), v.end());
	cout << q2.top() << endl;
}

3.priority_queue的模拟实现

3.1解析细节

• 回顾一下我们之前学习二叉树的时候，当时我们实现了向上调整和向下调整，这两个都可以实现堆排序。
• 当我们要插入一个数据的时候是头插还是尾插呢？因为priority_queue的底层是堆，也就是二叉树，但是这个二叉树的物理结构是数组，逻辑上是二叉树，所以如果我们选择头插的话就会打乱原来的二叉树结构，导致父子变兄弟，兄弟变叔侄。所以这里我们要选择尾插，同时还要保持priority_queue的特性，在每次插入一个数据的时候还用进行向上调整。
• 但我们要删除一个数据的时候，因为priority_queue是个优先级队列肯定是删除最大/最小的，也就是堆顶的数据，也就是头删，那我们可以直接进行头删吗？显然是不能的，因为这样做同样也会导致原来的二叉树结构，从而导致父子变兄弟，兄弟变叔侄。所以这里的办法是讲头上的数据与尾上的数据进行交换后在进行尾删最后在进行向上调整。
• 以上是我们回顾数据结构二叉树阶段学习的知识点，如果还有不懂的地方可以翻阅前期二叉树讲解部分，在哪里有系统的讲解。

3.2仿函数

• 在我们实现向上调整/向下调整的时候我们只能进行单一的>或者<的比较，也就是实现一种方案，但是如果我们想实现升序和降序的时候就要写两份，并且分开调用，这个办法明显比较挫。
• 我们在C语言阶段通常用到的是回调函数，但是这个办法的缺点就是调用的时候比较麻烦，实现起来也比较麻烦。

void adjust_up(int child)
{
	int faster = (child - 1) / 2;
	while (child > 0)
	{
		if (_con[child] > _con[faster])
		{
			std::swap(_con[child], _con[faster]);
			child = faster;
			faster = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void adjust_down(int faster)
{
	int child = faster * 2 + 1;
	while (child < _con.size())
	{
		if (child + 1 < _con.size() && _con[child + 1] > _con[child])
		{
			child++;
		}

		if (_con[child]>_con[faster])
		{
			std::swap(_con[faster], _con[child]);
			faster = child;
			child = faster * 2 + 1; 
		}
		else
		{
			break;
		}
	}
}

• 所以在C++中引入了仿函数的概念
  所谓仿函数简单点说就是一个重载了()的一个函数。
  使用起来跟调用函数很像，但又不是函数，所以叫做仿函数

class fun
{
public:
	bool operator()(in x, int y)
	{
		return x > y;
	}	
};

fun f
cout << f(1, 2) << endl;//这个样子看起来很像是一个函数调用实际上是：f.operator()(1, 2)这样调用的。

3.3具体实现

#pragma once
#include 
namespace qfw
{
	template
	class less
	{
	public:
		bool operator()(T x, T y)
		{
			return x > y;
		}
	};

	template
	class greater
	{
	public:
		bool operator()(T x, T y)
		{
			return x < y;
		}
	};


	template , class Comper = less>
	class priority_queue
	{
	public:
		void adjust_up(int child)
		{
			int faster = (child - 1) / 2;
			while (child > 0)
			{
				if (_cmp(_con[child] , _con[faster]))
				{
					std::swap(_con[child], _con[faster]);
					child = faster;
					faster = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(int faster)
		{
			int child = faster * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _cmp(_con[child + 1] , _con[child]))
				{
					child++;
				}

				if (_cmp(_con[child],_con[faster]))
				{
					std::swap(_con[faster], _con[child]);
					faster = child;
					child = faster * 2 + 1; 
				}
				else
				{
					break;
				}
			}
		}

		priority_queue()//这里要有个空的默认构造，原因是下面构造了一个priority_queue(InputIterator first, InputIterator last)有参构造
								//但是当实例化对象的时候，没有传参数的时候据选哟调用默认构造，但是类的特点就是如果定义了有参构造就不会
								//使用系统给的默认构造，所以这里要自己写一个默认构造。
		{}

		template 
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push(*first);
				++first;
			}
		}

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

		void pop()
		{
			std::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;
		Comper _cmp;
	};
}