C++——STL（stack类、queue类）

1.stack简介和使用

1.1 stack的简介

stack的文档介绍

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

 

1.2  stack的使用

 stack() :构造一个空的栈；

empty() :检测stack是否为空;

size() :返回stack中元素的个数;

top() :返回栈顶元素的引用;

push() :将元素val压入stack中;

pop() :将stack中尾部的元素弹出.

1.3 stack的模拟实现

template<class T,class con=deque<T>>
class stack
{
public:
	//构造
	stack(const con& ctnr = con())
		:_c(ctnr)
	{}
	//empty
	bool empty() const
	{
		return _c.empty();
	}
	//size
	size_t size()const
	{
		return _c.size();
	}
	T& top()
	{
		return _c.back();
	}
	const T& top()const
	{
		return _c.back();
	}
	//push
	void push(const T& val)
	{
		_c.push_back(val);
	}
	//pop
	void pop()
	{
		_c.pop_back();
	}
private:
	con _c;
};

2.queue简介和使用

2.1 queue的简介

queue的文档介绍

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

 

2.2queue的使用

 

queue()  :构造空的队列;

empty() :检测队列是否为空，是返回true，否则返回false;

size() :返回队列中有效元素的个数;

front() :返回队头元素的引用;

back() :返回队尾元素的引用;

push() :在队尾将元素val入队列;

pop() :将队头元素出队列.

2.3 queue的模拟实现

template<class T,class con=deque<T>>
class queue
{
public:
	//构造
	queue(const con& ctnr=con())
		:_c(ctnr)
	{}
	//empty
	bool empty()const
	{
		return _c.empty();
	}
	//size
	size_t size()const
	{
		return _c.size();
	}
	//front
	T& front()
	{
		return _c.front();
	}
	const T& front()const
	{
		return _c.front();
	}
	T& back()
	{
		return _c.back();
	}
	const T& back()const
	{
		return _c.back();
	}
	//push
	void push(const T& val)
	{
		_c.push_back(val);
	}
	//pop
	void pop()
	{
		_c.pop_front();
	}
private:
	con _c;
};

3.priority_queue(优先级队列)的简介和使用

3.1 priority_queue的简介

priority_queue的文档介绍

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元中最大的。
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
4. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
5. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

3.2 priority_queue的使用

priority_queue()/priority_queue(first,last)  :构造一个空的优先级队列；

empty() :检测优先级队列是否为空，是返回true，否则返回false;

size() :返回队列中有效元素的个数;

top() :返回优先级队列中最大(最小元素)，即堆顶元素;

push() :在优先级队列中插入元素x;

pop() :删除优先级队列中最大(最小)元素，即堆顶元素.

3.3 priority_queue的模拟实现

template<class T>
struct less
{
	bool operator()(const T& parent, const T& child)
	{
		return child > parent;
	}
};

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

template<class T,class con=vector<T>,class Compare=less<T>>
class priority_queue
{
public:
	//空的优先级队列
	priority_queue()
	{}
	template<class Iterator>
	priority_queue(Iterator first, Iterator last)
		:_c(first,last)
	{
		int count = _c.size();
		int root = (count - 2) / 2;
		for (; root >= 0; root--)
		{
			AdjustDown(root);
		}
	}
	//push
	void push(const T& val)
	{
		_c.push_back(val);
		AdjustUp(_c.size() - 1);
	}
	//pop
	void pop()
	{
		swap(_c[0], _c[_c.size() - 1]);
		_c.pop_back();
		AdjustDown(0);
	}
	//size
	size_t size()const
	{
		return _c.size();
	}
	//empty
	bool empty()const
	{
		return _c.empty();
	}
	//top
	const T& top()const
	{
		return _c.front();
	}
private:
	//向上调整
	void AdjustUp(int child)
	{
		Compare compare;
		int parent = (child - 1) / 2;
		while (parent >= 0)
		{
			if (compare(_c[parent], _c[child]))
			{
				std::swap(_c[parent], _c[child]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				return;
			}
		}
	}
	//向下调整
	void AdjustDown(int parent)
	{
		Compare compare;
		int child = parent * 2 + 1;
		while (child < _c.size())
		{
			if (child + 1 < _c.size() && _c[child + 1] > _c[child])
			{
				child = child + 1;
			}
			if (compare(_c[parent], _c[child]))
			{
				std::swap(_c[parent], _c[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				return;
			}
		}
	}
private:
	con _c;
};

4 关于适配器

4.1什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

 4.2 STL中stack和queue底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

 

 

4.3 关于deque

4.3.1 deque的原理

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。 

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组 。

底层结构如图：

 

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示： 

 

 

4.3.2 deque的缺陷 

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是比vector高的。 

与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。