C++容器——双端队列（deque）

1. 简介

deque是动态数组，也是双端数组，与vector相比，deque可以在队列头进行元素的删除和插入；

如果需要在队列的头和尾频繁的操作元素，可以使用deque

头文件和定义

#include <deque>

template<
    class T,
    class Allocator = std::allocator<T>
> class deque;

2. 初始化

初始化主要包括直接初始化、赋值初始化和拷贝初始化等；

#include <iostream>
#include <deque>
#include <string>

template<typename T>
void showInfo(T &t)
{
    for(auto &au : t)
    {
        std::cout<<au<<" ";
    }
    std::cout<<std::endl;
}


int main(int argc, char *argv[])
{
    std::deque<int32_t> d1;
    d1= {12, 14,23,56,66};
    showInfo(d1);

    std::deque<int32_t> d2{100, 112, 114, 155};    
    showInfo(d2);

    std::deque<int32_t> d3 = d1;
    showInfo(d3);

    std::deque<std::string> d4 = {"c++", "c", "Rust", "Golang"};
    showInfo(d4);

    return 0;
}

输出

12 14 23 56 66
100 112 114 155
12 14 23 56 66
c++ c Rust Golang

3. 使用

3.1 元素的访问

方法	说明
[] 或 at()	下标访问
front	数组头元素
back	数组尾元素
empty	数组判空
size	数组大小
max_size	最大容量
resize	改变大小
shrink_to_fit	改变deque所占内存的大小，减少到size的大小
clear	清空size大小

示例

int main(int argc, char *argv[])
{
    //1. at和[]
    std::deque<std::string> d1 = {"c++", "c", "Rust", "Golang", "java", "python"};
    std::cout<<d1.at(1)<<std::endl;
    std::cout<<d1[2]<<std::endl<<std::endl;

    //2. front back
    showInfo(d1);    
    std::cout<<"d1 front value is: "<<d1.front()<<std::endl;
    std::cout<<"d1 back value is: "<<d1.back()<<std::endl<<std::endl;

    //3.empty
    if(d1.empty())
    {
        std::cout<<"empty"<<std::endl;
    }
    else{
        std::cout<<"not empty"<<std::endl;
    }
    std::cout<<std::endl;

    //4.size max_size shrink_to_fit resize clear
    std::cout<<"size value is: "<<d1.size()<<std::endl;
    std::cout<<"max_size value is: "<<d1.max_size()<<std::endl<<std::endl;

    d1.resize(10);  //重新设置deque的大小
    std::cout<<"(resize)size value is: "<<d1.size()<<std::endl;
    std::cout<<"(resize)max_size value is: "<<d1.max_size()<<std::endl<<std::endl;
    //deque没有capacity()函数，因为其没有容量的限制

    d1.shrink_to_fit();   //清楚deque中的无用内存，一般会用在clear后面
    std::cout<<"(shrink_to_fit)size value is: "<<d1.size()<<std::endl;
    std::cout<<"(shrink_to_fit)max_size value is: "<<d1.max_size()<<std::endl<<std::endl;

    d1.clear();   //清空deque
    std::cout<<"(clear)size value is: "<<d1.size()<<std::endl;
    std::cout<<"(clear)max_size value is: "<<d1.max_size()<<std::endl<<std::endl;

    d1.shrink_to_fit();    //
    std::cout<<"(shrink_to_fit clean)size value is: "<<d1.size()<<std::endl;
    std::cout<<"(shrink_to_fit clean)max_size value is: "<<d1.max_size()<<std::endl<<std::endl;    

    return 0;
}

输出

c
Rust

c++ c Rust Golang java python
d1 front value is: c++
d1 back value is: python

not empty

size value is: 6
max_size value is: 576460752303423487

(resize)size value is: 10
(resize)max_size value is: 576460752303423487

(shrink_to_fit)size value is: 10
(shrink_to_fit)max_size value is: 576460752303423487

(clear)size value is: 0
(clear)max_size value is: 576460752303423487

(shrink_to_fit clean)size value is: 0
(shrink_to_fit clean)max_size value is: 576460752303423487

3.2 元素的修改

方法	说明
insert	插入元素，可以是任意位置，可以插入多个元素
emplace	插入元素，可以是任意位置，只能插入一个元素
push_back	数组尾部插入元素，先复制元素，在将元素插入到尾部
emplace_back	数组尾部插入元素，直接在数组尾部创建元素
push_front	数组头部插入元素，先复制元素，在将元素插入到头部
emplace_front	数组头部插入元素，直接在数组尾部创建元素
pop_back	删除队尾元素
pop_front	删除头部元素
erase	删除元素，可以是任意位置
swap	交换两个vector的内容
assign	重新对vector赋值
get_allocator	返回内存分配器

示例

int main(int argc, char *argv[])
{
    //1. 元素插入
    //insert
    std::deque<std::string> d1 = {"c++", "c", "Rust", "Golang"};
    std::deque<std::string> d2 = {"shell", "linux", "R"};
    d1.insert(d1.end(), "java");   //插入位置在最后
    showInfo(d1);

    d1.insert(d1.end(),d2.begin(), d2.end());
    showInfo(d1);

    //emplace
    d1.emplace(d1.begin(), "python");   //插入位置在最前端
    showInfo(d1);
    std::cout<<std::endl;

    //插入元素 push_back emplace_back push_front emplace_front
    d1.clear();
    d1.push_back("c++");
    d1.emplace_back("c");
    showInfo(d1);

    d1.push_front("Rust");
    d1.emplace_front("Golang");
    showInfo(d1);

    //2.元素删除
    d1.pop_back();   //删除队列尾部元素
    showInfo(d1);

    d1.pop_front();   //删除队列头元素
    showInfo(d1);

    d1.erase(d1.begin());   //删除指定位置的元素
    showInfo(d1);

    std::cout<<std::endl;
    std::cout<<"【swap result test】"<<std::endl;
    showInfo(d1);
    showInfo(d2);
    d1.swap(d2);
    showInfo(d1);
    showInfo(d2);

    return 0;
}

输出

c++ c Rust Golang java
c++ c Rust Golang java shell linux R
python c++ c Rust Golang java shell linux R

c++ c
Golang Rust c++ c
Golang Rust c++
Rust c++
c++

【swap result test】
c++
shell linux R
shell linux R
c++

3.3 迭代器

迭代器最好结合STL中的算法一起使用；迭代器的返回值最好用auto接受；

迭代器的类型包括：iterator、const_iterator、reverse_iterator和const_reverse_iterator

方法	说明
begin	返回数组的头元素（迭代器），其值可修改
end	返回数组的尾元素（迭代器），其值可修改
cbegin	返回数组的头元素（迭代器），其值不可修改，const属性
cend	返回数组的尾元素（迭代器），其值不可修改，const属性
rbegin	反序返回数组的头元素（迭代器），其值可修改，同end()
rend	反序返回数组的尾元素（迭代器），其值可修改，同begin()
crbegin	反序返回数组的头元素（迭代器），其值不可修改，同cend，const属性
crend	反序返回数组的头元素（迭代器），其值不可修改，同cbegin，const属性

迭代器的使用大同小异，和array的使用类似