priority_queue的模拟实现

小杨

容器适配器：priority_queue

priority_queue即优先级队列是一种容器适配器，根据严格的弱排序标准(即排序规则可以更改),他的第一个元素总是它所包含的元素中最大的。优先队列将特定容器类封装作为其底层容器类。标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

对于优先队列来说，需要支持随机访问迭代器，以便始终在内部保持堆结构。

优先级队列的接口

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

函数声明	接口说明
priority_queue()	构造一个空的优先级队列
priority_queue(first,last)	从给定的迭代器范围[first,last]中构建优先级队列，并调用调整方法，确保优先队列内部的元素始终保持堆结构
empty()	检测优先级队列是否为空，是返回true,否则返回false
top()	返回优先级队列中最大(最小元素),即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大(最小)元素，即堆顶元素

优先级队列涉及到堆的核心

为什么现有的元素是堆，插入元素了还能保持堆，即使删除了元素也能保持堆的性质，那么这个是因为向上调整算法和向下调整算法存在的原因。

向下调整算法

在用给定迭代器区间构造中，我们要用到向下调整算法，从而来实现保持他为堆的结构，并且删除元素时，即调用pop时，需要交换堆顶和堆尾的元素，然后删除堆尾，然后这个时候也是要用到向下调整算法的。
但是要用向下调整算法是要有条件的，以大堆为例子，就是你要向下调整的那个节点的左右子树必须必须都是大堆。
知道了这一点，来解释一下为什么上述两个条件都能默认用向下调整算法嘞，首先我们在使用迭代器区间构造时，肯定不能直接用向下调整算法，因为根节点左右子树可能不是堆，因此我们采用的是从倒数的第一个非叶子节点的子树开始调整，为什么嘞，因为此时倒数的第一个非叶子节点的左右子树的都分别只有一个叶子节点，这个时候，是大堆是小堆都可以，因此从倒数的第一个非叶子结点开始向上调整，一直调整到根节点的树，就可以调整成堆。而删除呢？先交换堆顶和堆尾，然后删除堆尾的元素，这个时候必定要向下调整了，因为我们的堆默认是大堆，这个时候把最小的数放到堆顶了，破坏了堆的结构，并且此时堆顶的左右子树都是大堆，因此就可以调整了。

向下调整代码:

void AdjustDown(int parent)
{
	int child = parent * 2 + 1;


	while (child < c.size())
	{
		if (child + 1 < c.size() && comp(c[child], c[child + 1]))
		{
			child++;
		}


		if (comp(c[parent], c[child]))
		{
			swap(c[parent], c[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			return;
		}
	}
}

向上调整算法

以大堆为例子，堆的向上调整算法在插入新元素的时候会用到，这个时候他的插入元素的父母是唯一确定的。然后如果插入的这个值比父亲节点大，就进行交换，庵后按照这个规律向上继续调整，停止条件是如果当孩子节点为堆顶时停止或者该节点比父亲节点小。

以下图为例子，本来是一个大堆，我又插入了一个70，破坏了大堆的结构，然后因此需要进行向上调整算法。70比其父节点30大，因此需要交换

交换完毕后，70的父节点75，满足大堆结构，因此此时停止调整就好。
堆向上调整代码:

	void AdjustUp(int child)
	{
		int parent = (child - 2) / 2;
		while (child > 0)
		{
			if (comp(c[parent], c[child]))
			{
				swap(c[parent], c[child]);
				child = parent;
				parent = (child - 2) / 2;
			}
			else
			{
				break;
			}
		}
	}

priority_queue模拟实现代码

namespace yang
{

	template<class T>
	struct less
	{
		bool operator()(const T& left, const T& right)
		{
			return left < right;
		}
	};


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


	};
	template <class T, class Container = std::vector<T>, class Compare = less<T> >
	class priority_queue
	{
	public:
		priority_queue()
			:c()
			, comp()
		{


		}
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			: c()
			, comp()
		{
			int count = c.size();
			int root = (count - 2) / 2;
			for (int i = root; i >= 0; --i)
			{
				AdjustDown(i);
			}
		}
		bool empty() const
		{
			return c.empty();
		}
		size_t size() const
		{
			return c.size();
		}
		const T& top() const
		{
			return c.front();
		}
		void push(const T& x)
		{
			c.push_back(x);
			AdjustUp(c.size() - 1);
		}
		void pop()
		{
			if (c.empty())
				return;


			swap(c.front(), c.back());
			c.pop_back();
			AdjustDown(0);
		}
	private:
		void AdjustUp(int child)
		{
			int parent = (child - 2) / 2;
			while (child > 0)
			{
				if (comp(c[parent], c[child]))
				{
					swap(c[parent], c[child]);
					child = parent;
					parent = (child - 2) / 2;
				}
				else
				{
					break;
				}
			}
		}


		void AdjustDown(int parent)
		{
			int child = parent * 2 + 1;


			while (child < c.size())
			{
				if (child + 1 < c.size() && comp(c[child], c[child + 1]))
				{
					child++;
				}


				if (comp(c[parent], c[child]))
				{
					swap(c[parent], c[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					return;
				}
			}
		}
		Container c;
		Compare comp;
	};
};