使用deque容器适配器完成栈，队列的创建，使用vector实现优先级队列的创建，仿函数类的简单实现

用container的deque实现栈和队列，以及仿函数类比较大小的实现

用deque实现栈stack

template<class T,class Container = deque<T>>
class Stack
{
public:
	void push(const T& val)
	{
		_c.push_back(val);
	}

	void pop()
	{
		_c.pop_back();
	}

	const T& top()
	{
		return c.back();
	}

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

	bool empty()const
	{
		return _c.empty();
	}
private:
	Container _c;
};

用deque实现队列queue

template<class T,class Container = deque<T>>
class queue
{
public:
	void push(const T& val)
	{
		_c.push_back(val);
	}
	void pop()
	{
		_c.pop_front();
	}
	T& front()
	{
		return _c.front();
	}

	T& back()
	{
		return _c.back();
	}

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

	bool empty()const
	{
		return _c.empty();
	}
private:
	Container _c;
};

使用vector实现优先级队列的创建

优先级队列中涉及堆排序，其中包括向上调整和向下调整，比较规则是通过仿函数类实现的，仿函数类中重载 bool operator()(参数列表）。默认进行从大到小排列，维护一个大堆。

template<class T,class Container = vector<T>,class Compare = Less<T>>
class Priority_Queue
{public:
	void push(const T& val)
	{
		_c.push_back(val);
		shiftUp(c.size() - 1);
	}
	void pop()
	{
		swap(_c[0], _c[c.size() - 1]);
		_c.pop_back();
		shiftDown(0);
	}
	T& top()
	{
		return _c.front();
	}
	size_t size()const
	{
		return _c.size();
	}
	bool empty()const
	{
		return _c.empty();
	}
private:
	void shiftDown(int parent)//向下调整算法,创建大堆
	{
		int child = 2 * parent + 1;
		while (child < _c.size())
		{
			if (child + 1 < _c.size() && _cmp(_c[child], _c[child + 1))
				++child;
			if (_cmp(_c[parent], _c[child]))
			{
				swap(_c[parent], _c[child]);
				parent = child;
				child = 2 * parent + 1;
			}
			else
				break;
		}
	}
	void shiftUp(int child)//向上调整算法
	{
		int parent = (child - 1) / 2;
		while (child > 0)
		{
			if (_com(_c[parent], _c[child]))
			{
				swap(c[parent], _c[child]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
				break;
		}
	}
private:
	Container _c;
	Compare _cmp;
};

仿函数类

仿函数类的调用方式：仿函数对象（参数列表）

template <class T>
struct Less
{
	bool operator()(const T& val1, const T& val2)
	{
		return val1 < val2;
	}
};


template <class T>
struct Greater
{
	bool operator()(const T& val1, const T& val2)
	{
		return val1 > val2;
	}
};