STL容器之＜deque＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

deque介绍

1. 双端队列。
2. 不保证元素的存储在连续的地址空间。
3. 支持随机访问
4. 在首尾插入和删除元素时间复杂度为O(1)，在其他位置插入元素时间复杂度为O(n)。

头文件

#include 

模块类定义

_Tp：表示存储的元素数据类型
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class deque{};

对象构造

/*默认构造函数*/
std::deque<int> deqInt1; 
/*构造指定长度的对象*/
std::deque<int> deqInt2(10);
/*构造指定长度的指定值的对象*/
std::deque<int> deqInt3(10,6);
/*复制拷贝构造函数*/
std::deque<int> deqInt4(deqInt3);
/*使用deqInt3的前7个元素构造对象*/
std::deque<int> deqInt5(deqInt3.begin(),deqInt3.begin()+7);
/*移动构造函数*/
std::deque<int> deqInt6(std::move(deqInt5));
/*初始化列表构造函数*/
std::deque<int> deqInt7({1,2,3,4,5,6,7});

初始化

/*初始化列表初始化*/
deqInt1 = {1,2,3,4,5};
/*使用assign函数初始化,清空容器，并使用迭代器进行赋值*/
deqInt1.assign(deqInt6.cbegin(), deqInt6.cend());
/*赋值5个8*/
deqInt1.assign(5,8);
/*assign中使用初始化列表赋值*/
deqInt1.assign({8,7,6,5,4,3,2,1});

元素访问

函数名	返回值	功能
[]	指定元素的值	访问元素
at()	指定元素的引用	访问元素
front()	首元素的引用	获取首元素
back()	元素的引用	获取末尾元素

/* 使用下标运算符访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout<< deqInt3[i] << " ";
}
/* 使用at访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout << deqInt3.at(i) << " ";
}

/* 访问对象第一个元素和最后一个元素 */
std::cout <<"front:"<< deqInt3.front() << std::endl;
deqInt3.front() = 1;
std::cout <<"after modify front:" << deqInt3.front() << std::endl;

/* 访问对象末尾元素，并修改值 */
std::cout <<"back:"<< deqInt3.back() << std::endl;
deqInt3.back() = 10;
std::cout << "after modify back:"<<deqInt3.back() << std::endl;

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase()	迭代器	清除指定位置的一个元素或通过迭代器指定范围内的元素
emplace()	迭代器	在指定位置构造并插入元素
emplace_front()	无	在队列头构造并插入元素
emplace_back()	无	在末尾构造并插入元素
insert()	迭代器或无	1）在指定位置插入1个元素。2）在指定位置插入指定数量的相同元素。3）通过指定迭代器范围在指定位置插入数据
pop_back()	无	删除队列尾元素
push_back()	无	在队列尾添加元素
pop_front()	无	删除队列头元素
push_front()	无	在队列头插入元素

/*在队列头插入元素*/
deqInt1.push_front(6);
/*在队列尾插入元素*/
deqInt1.push_back(8);
/*在队列首元素后构造并插入元素*/
deqInt1.emplace(deqInt1.begin()+1,10);
/*在队列头构造并插入元素*/
deqInt1.emplace_front(11);
/*在队列尾构造并插入元素*/
deqInt1.emplace_back(0);
/*在指定位置插入元素*/
deqInt1.insert(deqInt1.begin()+1, 12);
/*在指定位置插入多个相同元素*/
deqInt1.insert(deqInt1.begin(),3,9);
/*在指定位置插入一系列元素*/
deqInt1.insert(deqInt1.end(),deqInt7.begin(),deqInt7.begin()+5);
/*删除队列首元素*/
deqInt1.pop_front();
/*删除队列尾元素*/
deqInt1.pop_back();
/*删除指定位置元素*/
deqInt1.erase(deqInt1.begin()+1);
/*删除指定范围的元素*/
deqInt1.erase(deqInt1.end()-3,deqInt1.end());
/*清空队列中的元素*/
deqInt1.clear();

注：emplace、emplace_front、emplace_back()插入元素时直接构造并插入比insert效率高

容器大小

函数	返回值	功能
size()	std::size_t	获取当前容器中的元素数量
empty()	bool	判断当前容器是否为空，为空返回true，否则返回false
max_size()	std::size_t	返回容器的最大容量
resize()	无	重新指定容器可以容纳的元素数量，新大小大于原本大小时超出部分可使用指定元素填充，如果新大小小于指定大小时会删除容器原本末尾的数据。
shrink_to_fit()	无	丢弃容器中多余的容量。

/*判断队列中元素数量*/
std::cout << deqInt1.size() << std::endl;
/*获取对了最大能容纳的元素数量*/
std::cout << deqInt1.max_size() << std::endl;
/*判断队列是否为空*/
std::cout << std::boolalpha << deqInt1.empty() << std::endl;
/*重新指定队列的大小*/
deqInt1.resize(15);
/*重新指定队列大小，新的大小比之前大时使用指定值进行填充*/
deqInt1.resize(20,8);
/*删除容器中的多余的容量*/
deqInt1.shrink_to_fit();

迭代器

类型	功能
iterator	正向随机访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向随机访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向随机访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向随机访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向随机访问迭代器	返回指向deque对象首元素所在位置的迭代器
end()	正向随机访问迭代器	返回指向deque对象末尾元素的下一个位置的迭代器
cbegin()	常量正向随机访问迭代器	返回指向deque对象首元素所在位置的常量迭代器
cend()	常量正向随机访问迭代器	返回指向deque对象末尾元素的下一个位置的迭代器
rbegin()	逆向随机访问迭代器	返回指向deque对象末尾元素位置的迭代器
rend()	逆向随机访问迭代器	返回指向deque对象首元素的前一个位置的迭代器
crbegin()	常量逆向随机访问迭代器	返回指向deque对象末尾元素位置的常量迭代器
crend()	常量逆向随机访问迭代器	返回指向deque对象首元素的前一个位置的常量迭代器

std::deque<int>deqTest1({10,11,12,13,14,15,16,17,18,19});
/*正向随机访问迭代器，每个元素+10，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::deque<int>::iterator itr;
for (itr = deqTest1.begin(); itr != deqTest1.end(); itr++)
{
    /* 修改元素值每个元素+10 */
    *itr += 10; 
    /* 访问元素 */
    std::cout << *itr << " ";
}
std::cout<<std::endl;
/*常量正向随机访问迭代器，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::deque<int>::const_iterator cItr;
for (cItr = deqTest1.cbegin(); cItr != deqTest1.cend(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout << *cItr << " ";
}
std::cout<<std::endl;
/*逆向随机访问迭代器，每个元素+100，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::deque<int>::reverse_iterator rItr;
for (rItr= deqTest1.rbegin(); rItr!= deqTest1.rend(); rItr++)
{
    /* 修改元素值 */
    *rItr += 100; 
    /* 访问元素 */
    std::cout << *rItr << " ";
}
std::cout<<std::endl;

/*常量逆向随机访问迭代器，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::deque<int>::const_reverse_iterator crItr;
for (crItr= deqTest1.crbegin(); crItr!= deqTest1.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout << *crItr << " ";
}
std::cout << std::endl;

其他函数

函数名	返回值	功能
swap()	无	交换两个容器的元素

/*交互两个容器元素的值,无返回值*/
std::deque<int> deqSwap1 = {6,6,6,6,6};
std::deque<int> deqSwap2 = {8,8,8,8,8};
/*方式1， deqSwap1={8,8,8,8,8}, deqSwap2={6,6,6,6,6}*/
deqSwap1.swap(deqSwap2);
/*方式2，deqSwap1={6,6,6,6,6}, deqSwap2={8,8,8,8,8}*/
std::swap(deqSwap1,deqSwap2);