queue/stack/priority_queue

queue

1.queue的介绍

1. queue是队列,是一种专门用于FIFO（先进先出）中的操作，从一端输入,从一端输出的容器。
2. queue是容器适配器实现的。容器适配器就是指,将特定的容器封装作为queue的底层容器。
3. 底层容器可以是标准容器类模板之一。但底层容器至少要具有以下功能:
   empty：检测队列是否为空
   size：返回队列中有效元素的个数
   front：返回队头元素的引用
   back：返回队尾元素的引用
   push_back：在队列尾部入队列
   pop_front：在队列头部出队列

标准容器类deque和list满足了这些要求。vector不具有pop_front功能

2.queue的使用

queue() 构造空的队列
empty() 检测队列是否为空，是返回true，否则返回false
size() 返回队列中有效元素的个数
front() 返回队头元素的引用
back() 返回队尾元素的引用
push() 在队尾将元素val入队列
pop() 将队头元素出队列
只是一部分常用接口,因为比较简单在这里就不代码实现了。

3.queue的模拟实现

template<class T>
class queue
{
public:
	queue() {}
	void push(const T& x) {_c.push_back(x);}
	void pop() {_c.pop_front();}
	T& back() {return _c.back();}
	const T& back()const {return _c.back();}
	T& front() {return _c.front();}
	const T& front()const {return _c.front();}
	size_t size()const {return _c.size();}
	bool empty()const {return _c.empty();}
private:
	std::list<T> _c;
};
其实模拟实现很简单,全部使用的是容器适配器list当中的功能。

stack

1.stack的介绍

1.stack也就是栈,是一种先进后出的容器,只能从一端进出。
2.stack是通过容器适配器作为底层进行实现的。
3.容器适配器至少有以下功能:
empty:检测栈是否为空
push_back:尾部插入元素操作
pop_back:尾部删除元素操作
back:获取尾部元素的操作。

2.stack的使用

stack() 构造空的栈
empty() 检测stack是否为空
size() 返回stack中元素的个数
top() 返回栈顶元素的引用
push() 将元素val压入stack中
pop() 将stack中尾部的元素弹出
只是一部分常用接口,因为比较简单在这里就不代码实现了。

3.stack的模拟实现

这里我们选择用vector作为容器适配器进行模拟实现

class stack
	{
	public:
		stack() {}
		void push(const T& x)
		{
			_c.push_back(x);
		}
		void pop()
		{
			_c.pop_back();
		}
		T& top()
		{
			return _c.back();
		}
		int size()
		{
			return _c.size();
		}
		bool empty()
		{
			return _c.empty();
		}
	private:
		std::vector<T> _c;
	};

priority_queue

1.priority_queue的介绍

1. 优先队列是一种容器适配器,是有很严格的排序的。一般情况下,默认第一个元素为最大的元素
2. 优先队列的底层实现是一个堆,并且有底层容器。
3. 底层容器应具有以下功能:
   empty()：检测容器是否为空
   size()：返回容器中有效元素个数
   front()：返回容器中第一个元素的引用
   push_back()：在容器尾部插入元素
   pop_back()：删除容器尾部元素
4. list和vector都能够实现这样的功能,默认情况下,是使用vector作为优先队列的底层容器。

2.priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：
默认情况下priority_queue是大堆.

3.priority_queue的模拟实现

priority_queue()/priority_queue(first,
last) 构造一个空的优先级队列
empty()检测优先级队列是否为空，是返回true，否则返回false
top() 返回优先级队列中最大(最小元素)，即堆顶元素
push(x) 在优先级队列中插入元素x
pop() 删除优先级队列中最大(最小)元素，即堆顶元素

//less和greater是决定priority是大堆还是小堆。
template<class T>
struct less
{
	bool operator()(const T& left, const T& right)
	{
		return left < right;
	}
};

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

template<class T,class Container = std::vector<T>,class Compare = less<T>>
class priority_queue
{
public:
	priority_queue():_c() {}

	template<class Iterator>
	priority_queue(Iterator first, Iterator last)
		: _c(first, last)
	{
		// 将c中的元素调整成堆的结构
		int count = _c.size();
		int root = (count-1-1)>>1;//count-1 是最后一个元素的下标,再-1除2得到它的父节点。
		for (; root >= 0; root--)
			AdjustDown(root);
	}
	void push(const T& x)
	{
		_c.push_back(x);
		AdjustUP(_c.size() - 1);
	}
	
	void pop()
	{
	 	
		if (empty())
			return;
		swap(_c.front(), _c.back());
		_c.pop_back();
		AdjustDown(0);
	}
	T& top()
	{
		return _c.front();
	}
	bool empty()
	{
		return _c.empty();
	}
private:
	void AdjustUP(int child)
	{
		size_t parent = (child - 1) / 2;
		while (child)
		{
			if (Compare()(_c[parent], _c[child]))
			{
				swap(_c[child], _c[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
				return;
		}
	}
	void AdjustDown(int parent)
	{
		size_t child = parent * 2 + 1;
		while (child < _c.size())
		{
			if (child<_c.size() && Compare()(_c[child],_c[child+1]))
			{
				child++;
			}
			if (Compare()(_c[parent], _c[child]))
			{
				swap(_c[child], _c[parent]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
				return;
		}
	}
private:
	Container _c;
};