【C++】priority_queue(优先级队列)

目录

1. prioriy_queue介绍

2. priority_常用接口及模拟实现

2.1. 常用接口

2.2. 模拟实现 

---

1. prioriy_queue介绍

如果我们给每个元素都分配一个数字来标记其优先级，不妨设较小的数字具有较高的优先级，这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了。

这样，我们就引入了优先级队列 这种数据结构。

优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）查找（2）插入一个新元素 （3）删除 ，一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。

对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。
 

• 1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
• 2.类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
• 3.底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类

2. priority_常用接口及模拟实现

2.1. 常用接口

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

注意：默认情况下priority_queue是大堆。

​

​ 

 使用方式与list和queue类似，都没有迭代器，不能直接遍历。

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

int main()
{
	priority_queue<int> p;
	p.push(1);
	p.push(2);
	p.push(3);
	p.push(4);
	p.push(5);

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


    vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	priority_queue<int> p1(v.begin(), v.end()); // 通过迭代器区间构造 

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

	return 0;
}

2.2. 模拟实现 

构造函数

#pragma once
#include<vector>
#include<iostream>
#include<assert.h>
using namespace std;

namespace wt
{
	template <class T, class Container = vector<T>> // 默认储存容器为vector
	class priority_queue
	{
	template <class InputIterator>
	public:
		priority_queue() // 空构造不需要自己实现，默认调用储存容器的构造函数
		{}

		priority_queue(InputIterator first, InputIterator last) // 迭代器区间构造
			:_con(first, last) // 调用储存容器的迭代器区间构造
		{
            for (int i = (_con.size() - 1 - 1) / 2, i >= 0; ++i) // 仅仅将数据放进去没用，还要进行建堆
			{
				adjust_down(i); // 建堆的过程是从最后一个非叶子节点开始向下调整，将最大元素放到堆顶
			}
        }
	private:
		Container _con;
	};
}

常用接口 

public: 
       void push(const T& val)
		{
			_con.push_back(val); // 将数据尾插
			adjust_up(_con.size() - 1); // 然后向上调整
		}

		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]); // 将首尾数据交换，然后尾删，最后向下调整
			_con.pop_back();
			adjust_down(0);
		}

        // 其他接口套用储存容器即可
		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}

		const T& top()
		{
			return _con[0];
		}

 向上、向下调整

private:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[parent] < _con[child]) // 默认大堆，父亲比孩子小就交换
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

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

				if (_con[parent] < _con[child])
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

优先级队列实现好之后发现其实有一个问题：在大小堆的变换时，需要使用者自己去修改比较的符号，非常麻烦。

所以在这里引入了仿函数：仿函数(functor)，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

仿函数的是实现:

    template<class T>
	struct less
	{
		bool operator()(const T& a, const T& b)const
		{
			return a < b; // 这里如果T类型不支持<或> 比较则需要自己实现
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& a, const T& b)const
		{
			return a > b;
		}
	};

所以在上面向上向下调整时有一些修改：

template<class T , class Container = vector<T>, class compare = less<T>>    // 默认大堆    
private:
		
		void adjust_up(size_t child)
		{
			compare com; // 创建仿函数比较
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent] , _con[child])) // 使用仿函数比较
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(size_t parent)
		{
			compare com;
			size_t child = parent * 2 + 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[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}