📒博客主页:Morning_Yang丶
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文所属专栏:【C++拒绝从入门到跑路】
🙏作者水平有限,如果发现错误,敬请指正!感谢感谢!
一、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 yzy
{
/*
* 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 yzy
{
/*
* 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 是大堆。
less<int>
元素在底层按照小于符号 (<) 进行比较,降序。#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 }
-
如果要构造小堆,需要仿函数。
greater<int>
,元素在底层按照小于符号 (>) 进行比较,排升序。#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 yzy
{
// 仿函数类 less,按小于(<)进行比较,建大堆
template<class T>
struct less
{
bool operator()(const T& left, const T& right)
{
return left < right;
}
};
// 仿函数类 greater,按大于(>)进行比较,建小堆
template<class T>
struct greater
{
bool operator()(const T& left, const T& right)
{
return left > right;
}
};
/* 模板参数
* T: 优先级队列中存储的数据的类型
* Container: 适配优先级队列的容器类型,默认为vector
* Compare: 仿函数类型,默认是less(<),建大堆(也可以用库中的greater和less类模板)
*typename(class在VS也可)告诉编译器,后面是一个类型名称,后面等类模板实例化以后再去找他里面的value_type
*/
template <class T, class Container = std::vector<T>, class Compare = less<typename Container::value_type> >
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& x)
{
c.push_back(x);
//新元素向上排,less建大堆
AdjustUp(c.size() - 1);
}
// 删除堆顶元素
//将根节点换到最后,尾删
//换上来的节点向下调整。less:将大的换上来
void pop()
{
std::swap(c[0], c[c.size() - 1]);
c.pop_back();
AdjustDown(0);
}
// 判空
bool empty() const
{
return c.empty();
}
// 返回有效元素个数
size_t size() const
{
return c.size();
}
// 返回堆顶元素
const T& top() const
{
return c[0];
}
private:
Container c; // 成员变量,基础容器
Compare comp;
};
}
👉 默认成员函数:
实现了一个默认构造和构造函数模板,这样可以用一段迭代器区间 [first,last) 来初始化优先级队列,其它默认成员函数编译器会自动生成,在函数内会自动调用适配优先级队列的基础容器的对应函数。
// 默认构造函数
priority_queue()
{}
typename Container::iterator begin()
{
return c.Container::begin();
}
typename Container::iterator end()
{
return c.Container::end();
}
// 用迭代器区间[first,last)构造初始化
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
:c(first, last)//调用容器的拷贝构造函数
{
//将c中的元素调整为堆的结构,默认为大堆
int count = c.size();
int root = ((count - 1) >> 1);
for (; root >= 0; root--)
AdjustDown(root);
}
👉 push 和 pop 函数:
实现这两个函数,需要先实现向上调整和向下调整函数,为了让向上和向下调整函数,既可以调整成大堆也可以调整成小堆,还需要传仿函数:
// 向上调整,建大堆(小堆)
void AdjustUp(size_t child)
{
size_t parent = (child - 1) / 2;// 计算出父亲下标
while (child > 0)// 当孩子下标等于0时结束
{
//比较节点
//less:子节点大就换上去
if (comp(c[parent], c[child]))
{
std::swap(c[parent], c[child]);
child = parent;
parent = (child - 1) / 2;
}
else// 如果父亲大于(小于)孩子,说明已经是大(小)堆,不需要调整了
{
break;
}
}
}
// 向下调整,建大堆(小堆)
// 前提条件:左右子树都是大(小)堆
//less:找大的
void AdjustDown(size_t parent)
{
size_t child = 2 * parent + 1;// 计算出左孩子下标,默认左孩子最大
while (child < c.size())// 孩子下标超过数组范围时结束
{
// 1.选出左右孩子最小的那个,先判断右孩子是否存在
if (child + 1 < c.size() && comp(c[child], c[child + 1]))
{
child += 1;// 右孩子最大
}
// 2. 最大的孩子与父亲比较
if (comp(c[parent], c[child]))
{
std::swap(c[parent], c[child]);
parent = child;
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 的优点,而完美的避开了其缺陷。