C++___stack&&queue&&priority_queue

1. stack的介绍和使用

2. queue的介绍和使用

3. priority_queue的介绍和使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成大堆的结构。

传入less是大堆，传入greater是小堆，和我们常识是相反的。

3.1模拟实现priority_queue

#pragma once

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

namespace my_priority
{
	template<class T, class Container = vector<T>, class Compare = Greater<T>>
	class priority_queue
	{
	public:

		/*priority_queue()
		{}*/

		//和priority_queue()等价，都是强制编译器生成一个默认的构造函数，用来初始化成员
		priority_queue() = default;

		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)//在这里传迭代器进行初始化
		{
			//方法一：构建默认大堆
			for (size_t i = (size() - 1 - 1) / 2; i >= 0; --i)
			{
				Adjustdown(i);
			}

			//方法二
			/*for (size_t i = 1; i < size(); ++i)
			{
				Adjustup(i);
			}*/
		}

		const T& top() const
		{
			return _con.front();
		}

		//向上调整
		void Adjustup(int child)
		{
			Compare _com;
			int parent = (child - 1) / 2;
			
			while(child > 0)
			{
				if (_com(_con[child], _con[parent]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		//插入元素
		void push(const T& x)
		{
			_con.push_back(x);
			Adjustup(size()-1);//向上调整
		}

		//向下调整
		void Adjustdown(int parent)
		{
			size_t child = parent * 2 + 1;
			Compare _com;
			while (child < size())
			{
				if (child+1 < size() && _com(_con[child + 1], _con[child]))
				{
					child++;
				}

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

			}
		}

		//头删
		void pop()
		{
			assert(size() > 0);

			swap(_con.front(), _con.back());
			_con.pop_back();
			Adjustdown(0);
		}

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

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

	private:
		Container _con;
		
	};

}

4.仿函数

所谓的仿函数(functor)，是通过重载()运算符模拟函数行为的类。
　　因此，这里需要明确两点：
　　1　仿函数不是函数，它是个类；
　　2　仿函数重载了()运算符，使得它的对象可以像函数那样子调用(代码的形式好像是在调用函数)。