【C++ STL】容器适配器 Container adapter（stack & queue & priority_queue）

一、STL - stack

1.1 stack 的介绍

文档介绍：stack - C++ Reference (cplusplus.com)

// T: 容器中存储的元素的类型
template <class T, class Container = deque<T> > class stack;

stack 是一种「容器适配器」（container adapter），专门用在具有 LIFO (后进先出) 操作的上下文环境中，其中元素仅从容器的一端插入和提取。
stack 是作为容器适配器被实现的，「容器适配器」即是「对特定容器类封装」作为其底层的容器，并提供一组特定的成员函数来访问其元素，元素从特定容器的尾部(即栈顶)被压入和弹出，这被称为堆栈的顶部。
stack 的底层容器可以是任何标准容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
- empty：判空操作
- size：获取有效元素个数
- back：获取尾部元素操作
- push_back：尾部插入元素操作
- pop_back：尾部删除元素操作
标准容器类 vector、deque、list 均符合这些要求，默认情况下，如果没有为 stack 指定特定的底层容器类，则使用标准容器双端队列 deque。

容器适配器/配接器：不是直接实现的，封装其他容器，包装转换实现出来的。

1.2 stack 的使用

stack 没有迭代器，有了迭代器就可以随意访问元素了，不能保证「后进先出」的性质了。

成员函数	接口说明
stack()	构造一个堆栈容器适配器对象，构造空的栈。
empty	检查 stack 是否为空
size	返回 stack 中有有效元素的个数
top	返回栈顶元素的引用
push	压栈，将一个元素压入 stack 中
pop	出栈，将 stack 尾部元素弹出
swap（C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

👉 Example：

void test_stack1()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);

	// 遍历堆栈中的元素
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
}

1.3 stack 的模拟实现

不需要写构造函数，因为在默认构造函数的初始化列表阶段，自定义类型成员 _con 会自动调用它的默认构造函数

namespace winter
{
	/*
	* T: 堆栈中存储的数据的类型
	* Container: 适配堆栈的容器类型，默认为deque
	*/
	template<class T, class Container = std::deque<T>>
	class stack
	{
		// stack 是一个 Container 适配（封装转换）出来的
		// 把 Contariner 的尾部认为是栈顶

	public:
		bool empty() // 判空
		{
			return _con.empty();
		}

		size_t size() const // 获取有效元素的个数
		{
			return _con.size();
		}

		const T& top() const // 返回栈顶元素的引用
		{
			return _con.back();
		}

		void push(const T& val) // 压栈，尾插
		{
			_con.push_back(val);

			// 大家可能会有疑问，如果 _con 没有 push_back 接口怎么办呢？
			// 没有就报错呗，说明你不能适配我
		}

		void pop() // 出栈，尾删
		{
			_con.pop_back();
		}

		// C++11
		void swap(stack<T, Container>& st) // 交换两个容器的内容
		{
			// 注意：底层调用的是非成员函数 std::swap 来交换底层容器
			std::swap(_con, st._con);
		}

	private:
		Container _con; // 适配的容器
	};
    
    // 测试
    void test1()
	{
		//stack<int, std::vector<int>> st; // 用vector适配
		//stack<int, std::list<int>> st;   // 用list适配
		stack<int> st; // 默认用deque适配
		st.push(1);
		st.push(2);
		st.push(3);

		// 遍历堆栈中的元素
		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
}

二、STL - queue 的介绍

2.1 queue 的介绍

文档介绍：queue - C++ Reference (cplusplus.com)

// T: 容器中存储的元素的类型
template <class T, class Container = deque<T> > class queue;

队列是一种「容器适配器」（container adapter），专门用于在 FIFO (先进先出) 操作的上下文环境中，其中从容器一端插入元素，另一端提取元素。
队列作为容器适配器实现，「容器适配器」即「对特定容器类封装」作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作：
- empty：检测队列是否为空
- size：返回队列中有效元素的个数
- front：返回队头元素的引用
- back：返回队尾元素的引用
- push_back：在队列尾部入队列
- pop_front：在队列头部出队列
标准容器类双端队列 deque 和带头双向循环链表 list 满足了这些要求。默认情况下，如果没有为 queue 实例化指定容器类，则使用标准容器双端队列 deque。

2.2 queue 的使用

注意：queue 没有迭代器，有了迭代器就可以随意访问元素了，不能保证「先进先出」的性质了。

成员函数	接口说明
queue()	构造一个队列容器适配器对象。构造空的队列
empty	检测队列是否为空
size	返回队列中有效元素的个数
front	返回队头元素的引用
back	返回队尾元素的引用
push	入队，将一个元素从队尾入队列
pop	出队，将队头元素出队列
swap （C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

👉 Example：

void test_queue1()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);

	// 遍历队列中的元素
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
}

2.3 queue 的模拟实现

不需要写构造函数，因为在默认构造函数的初始化列表阶段，自定义类型成员 _con 会自动调用它的默认构造函数

namespace winter
{
	/*
	* T: 队列中存储的数据的类型
	* Container: 适配队列的容器类型，默认为deque
	*/
	template<class T, class Container = std::deque<T>>
	class queue
	{
	public:
		bool empty() // 判空
		{
			return _con.empty();
		}

		size_t size() const // 获取有效元素的个数
		{
			return _con.size();
		}

		const T& front() const // 返回队头元素的引用
		{
			return _con.front();
		}

		const T& back() const // 返回队尾元素的引用
		{
			return _con.back();
		}

		void push(const T& val) // 入队，尾插
		{
			_con.push_back(val);
		}

		void pop() // 出队，头删
		{
			_con.pop_front();
		}

	private:
		Container _con; // 适配的容器
	};

    // 测试
	void test11()
	{
		//queue<int, std::list<int>> q; // 用list适配
		queue<int> q; // 默认用deque适配
		q.push(1);
		q.push(2);
		q.push(3);

        // 遍历队列中的元素
		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}
}

三、STL - priority_queue

3.1 priority_queue 的介绍

文档介绍：priority_queue - C++ Reference (cplusplus.com)

/*
* T: 优先级队列中存储的数据的类型
* Container: 适配优先级队列的容器类型，默认用vector
* Compare: 仿函数的类型，默认是less(<)，建大堆
*/
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

优先队列是一种「容器适配器」（container adapter），根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的（默认为大堆）。
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从特定容器的 “ 尾部 ” 弹出，其称为优先队列的顶部。
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
- empty()：检测容器是否为空
- size()：返回容器中有效元素个数
- front()：返回容器中第一个元素的引用
- push_back()：在容器尾部插入元素
- pop_back()：删除容器尾部元素
标准容器类 vector 和 deque 满足这些需求。默认情况下，如果没有为特定的 priority_queue 类实例化指定容器类，则使用 vector。
需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap 和 pop_heap 来自动完成此操作。
需要包含头文件

3.2 priority_queue 的使用

注意：priority_queue 的所有元素，进出都一定的规则，只有顶端的元素（权值最高者），才有机会被外界取用。priority_queue 不提供走访功能，也不提供迭代器。

成员函数	接口说明
priority_queue() priority_queue(first, last)	构造一个 priority_queue 容器适配器对象。构造一个空的优先级队列 / 或者用一段迭代器区间 [first, last) 来初始化
empty	检测优先级队列是否为空
size	返回有效元素个数
top	返回优先级队列中最大(最小元素)，即堆顶元素
push	向优先级队列中插入一个元素
pop	删除优先级队列中最大(最小)元素，即堆顶元素
swap （C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

注意：

默认情况下，priority_queue 是大堆。元素在底层按照小于符号 (<) 进行比较。

#include<vector>
#include<queue>
#include<functional>

void test_priority_queue1() {
	priority_queue<int> pq; // 默认是大堆 -- 大的元素优先级高
	pq.push(4);
	pq.push(1);
	pq.push(7);
	pq.push(6);
	pq.push(2);
	pq.push(5);

	// 遍历优先级队列中的元素
	while (!pq.empty()) {
		cout << pq.top() << " "; // 堆顶元素
		pq.pop();
	}
    // result: 7 6 5 4 2 1
}

如果要构造小堆，需要仿函数。元素在底层按照小于符号 (>) 进行比较。

#include<vector>
#include<queue>
#include<functional>

void test_priority_queue2()
{
	// 构造小堆，需要给第三个模板参数传仿函数类greater，包含头文件<functional>
	priority_queue<int, vector<int>, greater<int>> pq; // 小堆 -- 小的元素优先级高
	pq.push(4);
	pq.push(1);
	pq.push(7);
	pq.push(6);
	pq.push(2);
	pq.push(5);
}

如果在 priority_queue 中存放自定义类型的元素：

需要用户在自定义类型中提供 > 或者 < 运算符的重载。
或者通过用户提供的针对比较自定义类型对象大小的仿函数类，控制比较方式。

class Date
{
public:
	Date(int year = 2020, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	bool operator<(const Date& d) const // < 运算符重载
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d) const // > 运算符重载
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d) // << 运算符重载
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}

    friend struct DateLess; // 仿函数类声明为友元
    
private:
	int _year;
	int _month;
	int _day;
};

void test_priority_queue1()
{
	// 大堆，需要用户在自定义类型Date中提供 < 的重载
	priority_queue<Date> q1;
	q1.push(Date(2017, 2, 28));
	q1.push(Date(2019, 10, 28));
	q1.push(Date(2019, 3, 3));
	cout << q1.top() << endl; // 输出堆顶元素（最大日期）

	// 小堆，需要用户在自定义类型Date中提供 > 的重载
	priority_queue<Date, vector<Date>, greater<Date>> q2;
	q2.push(Date(2017, 2, 28));
	q2.push(Date(2019, 10, 28));
	q2.push(Date(2019, 3, 3));
	cout << q2.top() << endl; // 输出堆顶元素（最小日期）
}

// 定义按小于(<)比较自定义类型对象大小的仿函数类
struct DateLess
{
	bool operator()(const Date& d1, const Date& d2)
	{
		return (d1._year < d2._year) ||
			(d1._year == d2._year && d1._month < d2._month) ||
			(d1._year == d2._year && d1._month == d2._month && d1._day < d2._day);
	}
};

void test_priority_queue2()
{
    // 大堆，第3个模板参数传针对比较自定义类型对象大小的仿函数类DateLess
    priority_queue<Date, vector<Date>, DateLess> q1;
	q1.push(Date(2017, 2, 28));
	q1.push(Date(2019, 10, 28));
	q1.push(Date(2019, 3, 3));
	cout << q1.top() << endl; // 输出堆顶元素（最大日期）
}

3.3 仿函数（⭐重要）

① 什么是仿函数

仿函数（Functor）又称为函数对象（Function Object），使一个类的使用看上去像一个函数，其实就是 在类中重载了 operator() 运算符，这个类就有了类似函数的行为，就是一个仿函数类了。

仿函数的语法几乎和我们普通的函数调用一样，调用仿函数时，实际上就是通过 仿函数类对象 调用重载后的 operator() 运算符，这种行为类似函数调用。

👉 Example：判断两个数谁大谁小

// 仿函数（函数对象） -- 自定义类型
// 该类型的对象，可以像函数一样去使用
struct Less
{
	bool operator()(const int& x, const int& y) // 重载()运算符
	{
		return x < y;
	}
};

void test_functor()
{
	// 仿函数的两种使用方式：

	// 方式1：
	Less less; // 构造函数对象
	cout << less(1, 2) << endl;  // 编译器会解释成: less.operator()(1, 2);

	// 方式2：
	cout << Less()(1, 2) << endl; // 构造一个匿名函数对象
}

👉 仿函数类还可以写成类模板，适应更多的类型：

template<class T> // 用于小于（<）不等式比较的函数对象类
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

template<class T> // 用于大于（>）不等式比较的函数对象类
struct Greater
{
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}
};

void test_functor()
{
	Less<int> less;
	cout << less(1, 2) << endl; // true
	
    Greater<int> greater;
	cout << greater(1, 2) << endl; // false
}

👉 像 less 和 greater 这种常见的仿函数类，在头文件中也有定义

Comparison operations:	接口说明
greater	用于大于（>）不等式比较的函数对象类
less	用于小于（<）不等式比较的函数对象类
……

// 仿函数less和greater是继承的binary_function，可以看作是对于一类函数的总体声明，这是函数做不到的

template <class T> struct greater : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {return x>y;}
};

template <class T> struct less : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {return x<y;}
};

② 模板实例化时，仿函数的使用

类模板一般是显式实例化的，在 <> 中指定模板参数的实际类型，所以类模板是传类型。比如：priority_queue

// 第1个模板参数是：存储数据的类型
// 第2个模板参数是：基础容器的类型
// 第3个模板参数是：仿函数的类型
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

void test()
{
    // 建小堆
    priority_queue<int, vector<int>, greater<int>> pq; // 传仿函数greater<int>类型
}

而函数模板一般是隐式实例化，让编译器根据实参推演模板参数的实际类型，所以函数模板是传对象。比如：sort

// 第1个模板参数：迭代器的类型
// 第2个模板参数是：仿函数的类型
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
// 函数的第1和第2个参数是：迭代器对象
// 函数的第3个参数是：仿函数类的对象

void test()
{
    vector<int> v { 5,3,2,4,1 };
    // 排降序(>)
    sort (v.begin(), b.end(), greater<int>()); // 传仿函数类greater<int>的匿名对象
    for (const auto& x : v)
        cout << x << " ";
    cout << endl;
}

3.4 priority_queue 的模拟实现

#include<iostream>
#include<vector>
#include<functional>
using namespace std;

namespace winter
{
	// 仿函数类 Less，按小于(<)进行比较，建大堆
	template<class T>
	struct Less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	// 仿函数类 Greater，按大于(>)进行比较，建小堆
	template<class T>
	struct Greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	/* 模板参数
	* T: 优先级队列中存储的数据的类型
	* Container: 适配优先级队列的容器类型，默认为vector
	* Compare: 仿函数类型，默认是Less(<)，建大堆（也可以用库中的greater和less类模板）
	*/
	template<class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
	public:
		// 默认构造函数
		priority_queue() {}

		// 用迭代器区间[first,last)构造初始化
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last);

		// 向上调整，建大堆（小堆）
		void AdjustUp(size_t child);

		// 向下调整，建大堆（小堆）
		// 前提条件：左右子树都是大(小)堆
		void AdjustDown(size_t parent);

		// 向堆中插入一个元素
		void push(const T& val)
		{
			_con.push_back(val); // 尾插

			AdjustUp(_con.size() - 1); // 从最后一个元素开始，向上调整
		}

		// 删除堆顶元素
		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]); // 堆顶元素交换到尾部

			_con.pop_back(); // 尾删

			AdjustDown(0);   // 从堆顶开始，向下调整
		}
		
        // 判空
		bool empty() { return _con.empty(); }
		
        // 返回有效元素个数
		size_t size() const { return _con.size(); }
		
        // 返回堆顶元素
		const T& top() const { return _con[0]; }

	private:
		Container _con; // 成员变量，基础容器
	};
}

👉 默认成员函数：

实现了一个默认构造和构造函数模板，这样可以用一段迭代器区间 [first,last) 来初始化优先级队列，其它默认成员函数编译器会自动生成，在函数内会自动调用适配优先级队列的基础容器的对应函数。

// 默认构造函数
priority_queue()
{}

// 用迭代器区间[first,last)构造初始化
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
    while (first != last)
    {
        // 插入数据
        _con.push_back(*first);
        first++;

        // 建堆，从倒数第一个非叶子节点开始向下调整
        int child = _con.size() - 1;
        int parent = (child - 1) / 2;
        for (int i = parent; i >= 0; i--)
        {
            AdjustDown(i);
        }
    }
}

👉 push 和 pop 函数：

实现这两个函数，需要先实现向上调整和向下调整函数，为了让向上和向下调整函数，既可以调整成大堆也可以调整成小堆，还需要传仿函数：

// 向上调整，建大堆（小堆）
void AdjustUp(size_t child)
{
    Compare com; // 仿函数对象

    size_t parent = (child - 1) / 2; // 计算出父亲下标

    while (child) // 当孩子下标等于0时结束
    {
        if (com(_con[parent], _con[child])) // 如果父亲小于(大于)孩子，需要把孩子往上调
        {
            // 交换孩子与父亲
            std::swap(_con[child], _con[parent]);

            // 更新孩子和父亲的下标
            child = parent;
            parent = (child - 1) / 2;
        }
        else // 如果父亲大于(小于)孩子，说明已经是大(小)堆，不需要调整了
        {
            break;
        }
    }
}

// 向下调整，建大堆（小堆）
// 前提条件：左右子树都是大(小)堆
void AdjustDown(size_t parent)
{
    Compare com; // 仿函数对象

    size_t child = 2 * parent + 1; // 计算出左孩子下标，默认左孩子最大

    while (child < _con.size()) // 孩子下标超过数组范围时结束
    {
        // 1.选出左右孩子最小的那个，先判断右孩子是否存在
        if (child + 1 < _con.size() && com(_con[child], _con[child + 1])) // 左孩子小于(大于)右孩子
        {
            child++; // 右孩子最大
        }

        // 2. 最大的孩子与父亲比较
        if (com(_con[parent], _con[child])) // 父亲小于(大于)最大的孩子，需要把父亲往下调
        {
            // 交换父亲与孩子
            std::swap(_con[parent], _con[child]);

            // 更新父亲和孩子的下标
            parent = (child - 1) / 2;
            child = 2 * parent + 1;
        }
        else // 父亲大于(小于)最大的孩子，说明已经是大(小)堆，不需要调整了
        {
            break;
        }
    }
}

四、容器适配器

stack 和 queue 和 priority_queue 往往不被认为是一个容器，而是一个容器适配器（Container adapter）。

adapter 原意是插座、适配器、接合器的意思。

4.1 什么是容器适配器

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

生活中的电源适配器：

4.2 STL 中容器适配器的种类

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

容器适配器	基础容器筛选条件	默认使用的基础容器
stack	基础容器需包含以下成员函数： empty() size() back() push_back() pop_back() 满足条件的基础容器有 vector、deque、list	deque
queue	基础容器需包含以下成员函数： empty() size() front() back() push_back() pop_front() 满足条件的基础容器有 deque、list	deque
priority_queue	基础容器需包含以下成员函数： empty() size() front() push_back() pop_back() 满足条件的基础容器有 vector、deque	vector

五、STL - deque（了解）

5.1 deque 的介绍

文档介绍：deque - C++ Reference (cplusplus.com)

template < class T, class Alloc = allocator<T> > class deque;

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

deque 支持很多操作，比如 vector 不支持头插头删（因为效率太低），deque 支持；list 不支持随机访问，deque 支持；看起来就像完美融合了 vector 和 list 的操作：

这样看来，deque 是一个很完美很优秀的容器，但在实际中 deque 并没有崭露头角，也没有取代 vector 和 list ，说明它还是有缺陷的。

这就需要来了解一下 deque 的底层实现了。

5.2 deque 的底层结构

首先看一下 vector 和 list 的优缺点对比，可以看到，它们的优缺点基本是反着来的：

vector 是一段连续的物理空间。

其优点是：

支持随机访问
空间利用率高，底层是连续空间，不容易造成内存碎片
CPU 高速缓存命中率很高

其缺点也非常明显：

空间不够时需要增容，增容代价很大（需要经过重新配置空间、元素搬移、释放原空间等），同时还存在一定的空间浪费

头部和中间插入删除，效率很低 O(n)

list 不是连续的物理空间，而是由一个个节点 “ 链接 ” 起来的。

其优点是：

按需申请释放空间，不会浪费空间

任意位置插入和删除数据都是 O(1)，因为不需要移动数据，插入删除效率高

其缺点也很明显：

不支持随机访问
空间利用率低，底层不是连续的空间，小节点容易造成内存碎片
CPU 高速缓存命中率很低

思考：那有没有一种折中的方案呢，既有 vector 的优点，也有 list 的优点。

👉 deque 的底层结构：

deque 并不是真正连续的空间，而是由一段段 固定大小 的连续小空间拼接而成的，实际 deque 类似于一个动态的二维数组，其底层结构如下图所示：

当需要增容时，只需要经过重新配置空间、元素搬移、释放原空间等过程，而是新增一个 buffer，存入数据，然后让中控数组指向新增的 buffer，将其管理起来。

👉 deque 的迭代器：

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

deque 的中控器、缓冲区、迭代器的相互关系：

5.3 deque 的优点和缺陷

与 vector 比较，deque 的优势是：

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

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

但是 deque 有一个致命缺陷：

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

deque 是一种折中方案的（妥协）设计，不够极致，随机访问效率不及 vector，任意位置插入删除不及 list，所以它能替代 vector 和 list 吗？是不能的。

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

stack 是一种后进先出的特殊线性数据结构，因此只要具有 push_back() 和 pop_back() 操作的线性结构，都可以作为 stack 的底层容器，比如 vector 和 list 都可以。

queue 是先进先出的特殊线性数据结构，只要具有 push_back() 和 pop_front() 操作的线性结构，都可以作为 queue 的底层容器，比如 list。

但是 STL 中对 stack 和 queue 默认选择 deque 作为其底层容器，主要是因为：

stack 和 queue 不需要遍历 (因此 stack 和 queue 没有迭代器)，只需要在固定的一端或者两端进行操作；
当 stack 中元素增长时，用 deque 比 vector 的效率高 (扩容时不需要搬移大量数据)；
当 queue 中的元素增长时，用 deque 不仅效率高，而且内存使用率高。刚好结合了 deque 的优点，而完美的避开了其缺陷。

注：参考书籍《STL源码剖析》