c++--优先级队列模拟实现

1.优先级队列

优先级队列就是将队列中的数据按照升序或降序来排列的一种数据结构，这种排列方式内部的排列方式为堆排序，优先级队列就是通过其它容器的适配生成的，优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

2.优先级队列的实现

优先级队列的实现并不复杂，只需在其它容器的基础上适配出来即可。

#pragma once
#include 
#include 
#include 
using namespace std;
//仿函数,用来比较大小
template
class Less
{
public:
	bool operator()(const T& x,const T& y)
	{
		return x > y;
	}
};

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

namespace sss
{
	template,class comple=Less>
	class private_queue
	{
		
	private:
		//向上建堆
		void Adjustup(int child)
		{
			comple com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{				 
				if (com(_con[child], _con[parent]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}
		//向下建堆
		void Adjustdown(int parent)
		{
			comple com;
			int child = parent*2+1;
			while (child <_con.size())
			{
				if ((child+1)<_con.size() && 
					com(_con[child+1] , _con[child]))
				{
					child = child+1;
				}
				if (com(_con[child], _con[parent]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = (parent) * 2+1;
				}
				else
				{
					break;
				}
			}
		}
	public:
		typedef template, comple = Less> Less_queue;
		typedef template, comple = Grate> Grate_queue;
		//初始化
		private_queue() 
		{}
		//拷贝构造
		template
		private_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				first++;
			}
			for (int i = (_con.size() - 2) / 2; i >= 0; i--)
			{
				Adjustdown(i);
			}
		}
		//插入
		void push(const T& val)
		{
			_con.push_back(val);
			
			Adjustup(_con.size()-1);
		}
		//删除
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);

			_con.pop_back();

			Adjustdown(0);
		}
		//队顶元素
		const T& top()
		{
			return _con[0];
		}
		//判空
		bool empty()
		{
			return _con.empty();
		}
		//计算大小
		size_t size()
		{
			return _con.size();
		}
	private:
		Contain _con;
	};
}

3.使用场景

优先队列中的每个元素都有各自的优先级，优先级最高的元素最先得到服务；优先级相同的元素按照其在优先队列中的顺序得到服务。 优先队列往往用堆来实现。 广泛应用在各种 广度优先搜索（Breadth-First-Search）中。