1.栈和队列文档理解

我们通过其上的介绍发现了几个点：

1.这个Container是什么，它后面的缺省值又是什么呢？

官网中对其的解释为第二个模板参数，那么它到底是什么呢？

2.stack被称为容器适配器，那么容器适配器又是什么呢？

3.既然vector，list和deque都可以作为Container，那么为什么默认的就是deque呢？

4.stack竟然没有迭代器，这是为什么呢？

2.为什么没有迭代器

首先栈和队列没有实现迭代器的原因很简单，因为它们不需要，它们是通过自己的先进先出和先进后出来进行数据操作，并且在遍历时它们需要先获取栈顶或者队头的元素打印后再将其pop出去，而不是像vector那样直接全部遍历。

日常使用：

stack<int> st;
st.push(1);
st.push(2);
st.push(3);
st.push(4);
st.push(5);

while (!st.empty())
{
	int top = st.top();
	cout << top << " ";
	st.pop();
}

3.Container到底是什么

要了解Container是什么，那我们就得明白什么是容器适配器（container adaptor）。

容器适配器是一种设计的模式，它可以实现代码的封装和复用，其可以将一个接口转换成另外一个我们使用的接口。

通俗理解它就是可以兼容传入的所有的合适的容器，作为底层实现的成员。

对于stack的实现，我们可以像list一样在底层封装结点自己实现，但是我们的栈有顺序栈(底层使用vector实现)和链栈（底层使用list实现），那么如果我们底层容器直接选择vector，就会有些死板，链式栈还需要再次实现一个，因此提出了适配器模式：既然vector和list两种容器都可以实现栈，而实现两个栈又很麻烦，那么我们可不可以实现传入对应的容器，让编译器自动适配实现出底层为传入容器的栈呢？

对于使用者 ，只暴漏其使用的接口，如push，pop等，而实现时，push等调用传入容器的对应函数，如果传入的是list，就调用list的为尾插，如果传入的容器是vector，就调用vector的尾插。

4.模拟实现源码–使用适配器模式

//栈的模拟实现
namespace Stack
{
    // 泛型编程--->适配器模式
    // 因为它们的底层既可以使用顺序表，也可以使用链表实现，如果只使用一种实现，就会写死
    // 可以使用模板，因为vector和list在效率上各有好坏，因此库中实现了一个两个都沾点的库函数deque来作为缺省值
    // 缺省模板
    template<class T, class Container = deque<T>>
    // 先进后出
    class stack
    {
    public:
        stack()
        {
            //私有成员变量为自定义类型，调用它的构造
        }

        void push(const T& val)
        {
            _c.push_back(val);
        }

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

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

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

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

        void swap(stack& s)
        {
            _c.swap(s._c);
        }
    private:
        Container _c;
        //vector<int> _c;
        //list<int> _c;
    };
}

//队列模拟实现
namespace Queue
{
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		queue()
		{

		}

		void push(const T& val)
		{
			_c.push_back(val);
		}

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

		const T& front() const
		{
			return _c.front();
		}

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

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

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

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

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

		void swap(queue& q)
		{
			_c.swap(q._c);
		}

	private:
		Container _c;
	};
}

5.deque

我们知道vector头删尾删的效率非常慢，但是其支持随机访问（使用[ ]来访问），而list头删尾删的效率比较高，但是其不支持随机访问。

而如果使用vector或者list来作为栈和队列的默认容器，都有一些缺点，因此发明了deque容器。

5.1定义

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

5.2底层结构

首先，deque的空间并不是真正的连续，如果是真正的连续就无法O(1)实现头尾的插入删除。它的空间是由许多段的空间拼接起来的，可以使用二维数组来理解。

首先其先开辟一个中控器数组，其数组中并不是存储有效值，而是存储指向一段空间的地址，该段空间被称为缓冲区，其最开始存储元素时，不是在中控器的最开始位置来开辟空间来存储数据，而是在中控数组中间位置的缓冲区开始。

头插头删

在中控数组中间位置的缓冲区开始，如果该缓冲区没有满，则直接在该缓冲区位置移动数据插入删除，如果该缓冲区已经满了，则在该缓冲区对应的中控数组前面的位置再进行如上操作，实现头部的插入删除。由于每次都是对缓冲区这一小部分片段来操作，这样就可以不需要移动大量的元素来实现头插头删。

随机访问

deque的随机访问通过其迭代器来实现。deque的迭代器结构如下。其中node指向其在中控器数组中的位置，first和last指向该缓冲区的开头和结尾，cur指向当前已经存储到的位置（即有效位置），如果该缓冲区遍历完成，则可以通过node找到其所在中控器中的位置，再++即可继续找到下一个位置。

扩容

由于其是数组，如果空间存储满了，则需要扩容，deque的扩容只需要重新开好中控器数组的空间，然后将旧的中控器中的存储缓冲区的地址拷贝到新的中控器数组中即可。

5.3缺陷

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

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

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

5.4为什么选择deque作为stack和queue的底层容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

1.stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。
2.在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

结合了deque的优点，而完美的避开了其缺陷。