1.stack和queue

stack和queue的相关接口如下：

stack

queue

我们发现不管是stack还是queue，它们都有push和pop，不区分push_back和push_front，这是由它们的入栈特定顺序特性决定的，并且它们都没有迭代器，stack只有top，queue只有front和back这使得我们只能以规定的方式去访问这个stack或者queue

emplace相当于入栈，一般我们用push就可以了。

2.stack和queue的模拟实现

我们已经知道stack、queue和vector、list本质上并没有区别，所以我们可以将复用的思想带到它们的实现中，并且我们可以利用模板对于同一个stack模板，使用不同的底层来实现。这体现了继迭代器模式后的第二种设计模式：适配器模式，即转换。

下面是它们的实现

template<class T, class Container = vector<T>>
class stack
{
public:
	stack(const Container& con = Container())
		:_con(con)
	{}

	void push(const T& val)
	{
		_con.push_back(val);
	}		
		
	void pop()
	{
		_con.pop_back();
	}		
		
	T& top()
	{
		return _con.back();
	}

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

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

	void swap(stack& st)
	{
		std::swap(_con, st._con);
	}


private:
	Container _con;
};
	
template<class T, class Container = list<T>>
class queue
{
public:
	queue(const Container& con = Container())
		:_con(con)
	{}

	void push(const T& val)
	{
		_con.push_back(val);
	}		
		
	void pop()
	{
		_con.pop_front();
	}		
		
	T& back()
	{
		return _con.back();
	}		
		
	T& front()
	{
		return _con.front();
	}

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

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

	void swap(queue& q)
	{
		std::swap(_con, q._con);
	}

我们可以看出，stack和queue的实现几乎不需要自己实现具体功能，我们只需要关注上层功能而不是底层的细节，这极大地体现了封装的特性。

代码中仍有一些细节点需要注意：

（1）为什么只写了构造但没有写析构？为什么构造有缺省值

构造时我们可能空构造，需要缺省值，也有可能带参构造，带参构造需要我们形参接收，这里展示的是拷贝构造的情况，析构的时候成员_con作为自定义类型会去调用自己的析构函数，不会存在内存泄露的情况，所以不需要我们显式的去写析构

（2）swap为什么使用std::swap？

事实上，当我们包含了<vector><list>后，std域里的swap函数就多了几个重载，这几个重载是专门针对vector和list类型的，_con和q._con是Container类型，也就是vector<int>或list<int>类型，会去调用重载的效率较高的swap函数。

之所以std里重载swap函数，就是为了让我们在不知vector类里有swap成员函数的情况下也能高效地交换（只交换指针的值而不是交换所有指向的值）。因此除了这种写法，我们还可以显式调用vector类的成员函数

（3）stack只能以vector作为容器吗？

vector是连续的物理结构，下标访问快，但头插效率极低。因此vector不支持头插头删。在queue中pop使用了pop.front()，在vector里没有这个接口，所以不能使用vector实现queue，但是我们如果用erase来实现pop也可以，这样就可以用vector实现queue了，但并不建议这么做，因为vector实现queue本就是效率极低的做法。

list是分散的物理结构，任意位置插入删除效果都不错，但下标访问效率低。因此list不支持下标访问。但是stack和queue都没用到下标访问，因此我们可以用list实现queue和stack。

事实上，stack和queue在STL中都是以deque作为默认的容器。我们发现，vector和list本就是两个极端的存储结构。所以deque是结合vector、list，能同时进行下标访问和push_back、push_front等操作的容器。

deque用buff小数组+中控数组来实现它的功能，是vector和list存储的结合体，虽然支持下标访问，但它的没vector快，deque[]偶尔用用还行，头尾删除不错。我们适当了解一下deque即可，不用深究，因为deque本不算一个效率高的容器。

3.优先级队列和仿函数

priority_queue本质上是堆，我们只要掌握了堆，优先级队列的核心就能很快完成了。

但是priority_queue用到了仿函数的知识点，在大堆小堆的处理和我们C语言有所不同

（1）仿函数：

仿函数，即模仿函数的一个类，我们看下面的代码：

comp(1,2)是我们常见的函数的写法，但它的本质是是一个类重载了operator()后表现出来的类似于函数的特性。仿函数实现起来也相当简单，只要理解了它的实质就能很快上手

但是仿函数和构造函数容易搞混，一定要注意仿函数是要针对已创建的对象调用而不是针对类来调用，那种写法是构造函数而不是仿函数

（2）优先级队列

优先级队列的功能很简单，就是结合vector、仿函数实现堆，核心代码就是AdjustUp和AdjustDown。

建议将AdjustUp和AdjustDown放进private，对外只提供push、pop这样的接口，体现封装的特性。

注意当仿函数是less时默认是大堆，greater默认是小堆，在我们进行数值比较时要注意谁在前谁在后，因为顺序不同，会影响返回值，从而影响我们生成的堆的类型。

由于堆相关的知识前面我已经详细讲过，这里就不多阐述了。

完整代码如下：

namespace my_priority_queue
{
	template<typename T>
	class less
	{
	public:
		bool operator()(const T& t1, const T& t2)
		{
			return t1 < t2;
		}
	};	
	
	
	template<typename T>
	class greater
	{
	public:
		bool operator()(const T& t1, const T& t2)
		{
			return t1 > t2;
		}
	};


	template<typename T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:

		priority_queue() = default;

		template<typename iterator>
		priority_queue(iterator begin, iterator end)
		{
			while (begin != end)
			{
				_con.push_back(*begin);
				begin++;
			}

			for (int parent = (int)(size() - 2) / 2; parent >= 0; parent--)
			{
				AdjustDown(parent);
			}

		}

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

		void push(const T& val)
		{
			_con.push_back(val);
			AdjustUp(size() - 1);
		}

		void pop()
		{
			std::swap(_con[0], _con[size() - 1]);
			_con.pop_back();
			AdjustDown(0);
		}

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

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

		void swap(priority_queue& p)
		{
			std::swap(_con, p._con);
		}



	private:
		void AdjustUp(size_t child)
		{
			Compare comp;

			size_t parent = (child - 1) / 2;

			while (child > 0)
			{
				if (comp(_con[parent], _con[child]))
					std::swap(_con[parent], _con[child]);

				child = parent;
				parent = (child - 1) / 2;
			}
		}

		void AdjustDown(size_t parent)
		{
			Compare comp;

			size_t child = parent * 2 + 1;

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

				if(comp(_con[parent], _con[child]))
					std::swap(_con[parent], _con[child]);

				parent = child;
				child = parent * 2 + 1;
			}
		}


	private:
		Container _con;
	};
}