优先级队列的详解

一.什么是适配器

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

三.简单看一下库的参数和接口

注意：这里解释一下Compare是一个仿函数，STL的六大组件之一。以为C++是非常排斥使用函数指针，所以它的出现是为了代替函数指针。我们可以看看它的用法。

template<class T>
class Less
{
public:
	bool operator()(T a, T b)
	{
		return a < b;
	}
};

接下来看看接口

四.使用

int main()
{
	/*Less<int> less1;
	cout << less1(1, 2) << endl;

	Less<double> less2;
	cout << less2(1.2, 2.4) << endl;*/
	ljw::priority_queue<int,vector<int>,less<int>> q;//大堆
	//ljw::priority_queue<int,vector<int>,greater<int>> q;//小堆
	q.push(2);
	q.push(5);
	q.push(1);
	q.push(4);
	q.push(3);

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

	return 0;
}

建的是大堆，底层默认用的的less。

五.实现

namespace ljw
{
	template<class T,class Cantainer=vector<T>,class compare=less<T>>
	class priority_queue
	{
	public:
		void adjust_up(size_t child)
		{
			compare con;
			size_t pather = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[pather] < _con[child])
				if(con(_con[pather],_con[child]))
				{
					swap(_con[pather], _con[child]);
					child = pather;
					pather = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t pather)
		{
			compare con;
			size_t child = pather * 2 + 1;
			while (child < _con.size())
			{
				/*if (child + 1 < _con.size() &&
					_con[child]<_con[child+1])*/
				if(child+1<_con.size()&&
					con(_con[child] ,_con[child + 1]))
				{
					child++;
				}
				if (con(_con[pather] ,_con[child]))
				{
					swap(_con[pather], _con[child]);
					pather = child;
					child = pather * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		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);
		}
		bool empty()
		{
			return _con.empty();
		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Cantainer _con;
	};
}

以上就是priority_queue的详解了，希望对你有点帮助。