C++初阶：容器适配器priority_queue常用接口详解及模拟实现、仿函数介绍

1. priority_queue的介绍和使用

1.1 priority_queue的初步介绍

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

1.2 priority_queue的使用

• priority_queue() ：   构造一个空的优先级队列
• priority_queue(first, last)：    构造一个优先级队列，包含范围为[first, last)的元素
• empty()：    检测优先级队列是否为空，是返回true，否则返回false
• top()：    返回优先级队列中最大（最小）元素，即堆顶元素
• push(x)：    在优先级队列中插入元素x
• pop()：    删除优先级队列中最大（最小）元素，即堆顶元素

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

int main()
{
	my_priority_queue<int> pq;//这里默认是大堆
	pq.push(3);
	pq.push(2);
	pq.push(6);
	pq.push(9);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

	my_priority_queue<int, vector<int>, greater<int>> pq2;//这里传入一个类型greater<int>(马上就讲了)
	pq2.push(3);
	pq2.push(2);
	pq2.push(6);
	pq2.push(9);
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;
	return 0;
}

结果：

1.3 进一步补全介绍

优先队列（priority_queue）是一个特殊的队列，它根据元素的优先级进行排序，而不是按照它们被插入的顺序。在C++中，优先队列通常使用堆（heap）数据结构来实现，这使得它能够在==O(l o g n lognlogn)的时间复杂度内对元素进行插入和删除操作，并能够以O(1)的时间复杂度获取队列中的最大（或最小）==元素

以下是优先队列（priority_queue）的一些重要特性和接口：

1.构造函数：

• priority_queue<Type, Container, Compare>：创建一个优先队列对象，其中Type是元素类型，Container是底层容器类型（默认为vector），Compare是元素比较的函数对象类型（默认为std::less，用于最大堆）。
• priority_queue(first, last)：使用范围为[first, last)的迭代器构造一个优先队列。

2.默认行为：

• 默认情况下，优先队列是最大堆，即最大元素位于堆顶。可以通过自定义比较函数对象来改变这一行为，从而创建最小堆或者基于自定义的优先级规则进行排序。

3.底层实现：

• 在C++中，优先队列通常使用vector或deque作为底层容器，并通过堆算法来维护元素的顺序。

2. 什么是仿函数？

C++中的仿函数是指那些能够像函数一样调用的对象，它们的类至少需要有成员函数operator()()。
仿函数可以是任何类型的对象，只要它的类重载了运算符()，它就能够被调用，就可以作为函数使用。
在C++中，标准模板库（STL）中的一些容器算法使用仿函数来封装各种操作，使得这些操作可以应用于容器中的元素。

仿函数可以是用户自定义的，也可以是C++标准库中定义的。例如，STL中的std::less和std::greater就是两个标准的比较仿函数，它们用于排序算法中。用户也可以定义自己的仿函数

总结：

C++的仿函数是重载了operator()的类实例化的对象，它可以被像函数那样调用

举个例子：

下图是一个可以简单进行大于比较的仿函数和它的类：

3. 模拟priority_queue

文件规划和一览

priority_queue.h:用来实现queue

test.cpp:进行测试

3.1 模拟priority_queue（priority_queue.h）

#pragma once

namespace CH
{
	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=greater<T>>
	class my_priority_queue
	{
	public:
		void adjust_down(int parent)
		{
			compare com;
			int child = 2 * parent + 1;
			while (child<_con.size())
			{
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = 2*parent + 1;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_up(int child)
		{
			int parent = (child - 1) / 2;
			while (child>0)
			{
				compare com;
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent= (child - 1) / 2;
				}
				else
				{
					break;
				}
				
			}
		}
	public:
		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);
		}
		T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}


	private:
		container _con;
	};
}

3.2测试（test.cpp)

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<list>

using namespace std;

#include"priority_queue.h"

int main()
{
	CH::my_priority_queue<int> pq;
	pq.push(1);
	pq.push(3);
	pq.push(2);
	pq.push(5);

	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

	CH::my_priority_queue<int, vector<int>, greater<int>> pq2;
	pq2.push(2);
	pq2.push(6);
	pq2.push(9);
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;
	return 0;
}

结果：