STL_priority_queue

• 了解priority_queue
• 常见接口
• 模拟实现

了解priority_queue

---

1.priority_queue（优先级队列）

在stl六大组件中，优先级队列是一个容器适配器，它在底层实现的是堆。其底层容器可以是具有随机访问且具有以下功能的容器。

• empty()
• size()
• top()
• pop_back();
• push_back()

标准vector和deque都满足上述要求，但是vector作为底层适配容器更好，所以stl库里默认的底层容器是vector

2.仿函数

仿函数，也叫做函数对象。在priority_queue中，仿函数作为类型模板参数传入,通常重载();

	template<class T>
	struct less
	{
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};
	//当用less创建一个对象时，对象可以像函数一样使用
	// less le;
	// cout << le(a, b);

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

	less ls;

接口

---

bool empty() const;
size_t size() const;
const T& top() const;
void push(const T& val);
void pop();

模拟实现

---

namespace zs
{


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

	template<class T>
	struct greater
	{
		bool operator()(const T& a, const T& b)
		{
			return a > b;
		}
	};
	//Compare是传入的仿函数
	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:

		//默认是大堆
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
                //匿名对象
				if (Compare()(_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 = 2 * parent + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() \
					&& Compare()(_con[child], _con[child+1]))
				{
					child++;
				}

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

		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);
		}

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

		size_t size() const
		{
			return _con.size();
		}
		size_t empty()const
		{
			return _con.empty();
		}
	private:
		Container _con;

	};


}