empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素

4.需要支持随机访问迭代器,以便始终在内部保持堆结构.

5. 标准容器类vector和deque满足这些需求.默认情况下,如果没有为特定的priority_queue类实例化指定容器类,则使用vector.

4.2priority_queue的使用

4.3 priority_queue的模拟实现

Let’s first understand what a functor is

template<class T>
struct Greate
{
	bool operator()(const T& x, const T& y) const
	{
		return x > y;
	}
};
int main()
{
	Greate<int> gg;
	cout << gg(6, 3) << endl;

	return 0;
}

Objects can be used like functions are called

再看下sort

struct Goods
{
	string _name;
	double _price;
	size_t _saleNum;
};
struct LessPrice
{
	bool operator()(const Goods& g1, const Goods& g2) const
	{
		return g1._price < g2._price;
	}
};

int main()
{

	Goods gds[4] = { { "苹果", 2.1, 1000}, { "香蕉", 3.0, 200}, { "橙子", 2.2,300}, { "菠萝", 1.5,50} };

	sort(gds, gds + 4, LessPrice());

	return 0;
}

 结果：

 模拟实现：

namespace LF
{
	template<class T>
	struct Less
	{
	public:
		bool operator()(const T& x, const T& y) const
		{
			return x < y;
		}
	};
	template<class T>
	struct Greate
	{
		bool operator()(const T& x, const T& y) const
		{
			return x > y;
		}
	};
	template<class T, class Container = vector<int>, class compare = Less<T>>//The default is big push
	class Priority_queue
	{
	public:
		void Adjustup(int child)
		{
			Compare comFunc;//Create the object with that functor
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (comFunc(_con[parent], _con[child]))//重载了()
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void AdjustDown(int parent)
		{
			Compare comFunc;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && comFunc(_con[child], _con[child + 1]))
				{
					++child;
				}
				if (comFunc(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);

			AdjustUp(_con.size() - 1);
		}
		void pop()
		{
			assert(!_con.empty());
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			AdjustDown(0);
		}

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

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

		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con;

	};

}
void test2()
{
	LF::Priority_queue<int> p;
	p.push(3);
	p.push(8);
	p.push(6);
	p.push(4);
	p.push(1);
	p.push(9);
	p.push(2);
	while (!p.empty())
	{
		cout << p.top() << " ";
		p.pop();

	}
	cout << endl;

}