C++提高编程 3 STL常用容器 -deque容器

3.3  deque容器

3.3.1  deque基本概念

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别：

1、vector对于头部的插入删除效率低，数据量越大，效率越低；

2、deque相对而言，对头部的插入删除速度比vector快；

3、vector访问元素时的速度会比deque快，这和两者内部实现有关

 

deque内部工作原理： 

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

 

 尾插为：

 

 头插：

 

 deque容器的迭代器也是支持随机访问的；

 

3.3.2 deque构造函数

功能描述：deque容器构造

函数原型：

deque<T> deqT;　　　　　　　　//默认构造形式

deque(beg, end);　　　　　　　　//构造函数将[beg， end)区间中的元素拷贝给自身

deque(n, elem);　　　　　　　　//构造函数将n个elem拷贝给自身

deque(const deque &deq);　　　　//拷贝构造函数

#include<iostream>
using namespace std;
#include<deque>

void printDeque(const deque<int>&d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //*it = 100;        //加一个const 容器中不可以修改，只读
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    deque<int>d1;
    for (int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);                        //0 1 2 3 4 5 6 7 8 9

    deque<int>d2(d1.begin(), d1.end());
    printDeque(d2);                        //0 1 2 3 4 5 6 7 8 9

    deque<int>d3(10, 100);
    printDeque(d3);                        //100 100 100 100 100 100 100 100 100 100

    deque<int>d4(d3);
    printDeque(d4);                        //100 100 100 100 100 100 100 100 100 100
}
int main()
{
    test1();

    system("pause");
    return 0;
}

deque容器和vector容器的构造方式几乎一致，灵活使用即可

 

3.3.3 deque赋值操作

功能描述：给deque容器赋值

函数原型：

deque& operator=(const deque &deq);　　//重载等号操作符

assign(beg, end);　　　　　　　　　　　 //将[beg, end)区间中的数据拷贝赋值给本身

assidn(n, elem);　　　　　　　　　　　   //将n个elem拷贝赋值给本身

#include<iostream>
using namespace std;
#include<deque>

//deque容器赋值
void printDeque(const deque<int>&d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    deque<int>d1;
    for (int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);                        //0 1 2 3 4 5 6 7 8 9
    
    //operator=赋值
    deque<int>d2;
    d2 = d1;
    printDeque(d2);                        //0 1 2 3 4 5 6 7 8 9

    //assign赋值
    deque<int>d3;
    d3.assign(d1.begin(), d1.end());
    printDeque(d3);                        //0 1 2 3 4 5 6 7 8 9

    deque<int>d4;
    d4.assign(10, 100);
    printDeque(d4);                        //100 100 100 100 100 100 100 100 100 100
}
int main()
{
    test1();

    system("pause");
    return 0;
}

 

3.3.4 deque大小操作

功能描述：

　　对deque容器的大小进行操作，deque没有容量概念。

函数原型：

　　deque.empty();　　　　　　//判断容器是否为空

　　deque.size();　　　　　　　//返回容器中元素的个数

　　deque.resize(num);　　　　//重新指定容器长度为num，若容器变长，则以默认值填充新位置，若变短，则删除末尾超出部分的元素

　　deque.resize(num, elem); 　//重新指定容器长度为num，若容器变长，则以elem填充新位置，若变短，则删除末尾超出部分的元素

#include<iostream>
using namespace std;
#include<deque>

//deque容器大小
void printDeque(const deque<int>&d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test1()
{
    deque<int>d1;
    for (int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);                        //0 1 2 3 4 5 6 7 8 9
    
    if (d1.empty())
    {
        cout << "d1为空" << endl;
    }
    else
    {
        cout << "d1不为空" << endl;
        cout << "d1大小为：" << d1.size() << endl;    //d1大小为：10
        //deque没有容量概念
    }

    //重新指定大小
    //d1.resize(20);
    //printDeque(d1);                        //0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0

    d1.resize(20, 1);
    printDeque(d1);                            //0 1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1

    d1.resize(5);
    printDeque(d1);                            //0 1 2 3 4
}
int main()
{
    test1();

    system("pause");
    return 0;
}

 

3.3.5 deque插入和删除

功能描述：在deque容器中插入或删除数据

 

#include<iostream>
using namespace std;
#include<deque>

//deque容器插入和删除
void printDeque(const deque<int>&d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}


//两端操作
void test1()
{
    deque<int>d1;
    //尾插
    d1.push_back(10);
    d1.push_back(20);

    //头插
    d1.push_front(100);
    d1.push_front(200);

    printDeque(d1);            //200 100 10 20

    //尾删
    d1.pop_back();
    printDeque(d1);            //200 100 10

    //头删
    d1.pop_front();
    printDeque(d1);            //100 10
}

void test2()
{
    deque<int>d1;
    d1.push_back(10);
    d1.push_back(20);
    d1.push_front(100);
    d1.push_front(200);

    printDeque(d1);                        //200 100 10 20

    //insert插入
    d1.insert(d1.begin(),1000);            
    printDeque(d1);                        //1000 200 100 10 20

    d1.insert(d1.begin(), 2, 10000);
    printDeque(d1);                        //10000 10000 1000 200 100 10 20

    //按照区间进行插入
    deque<int>d2;
    d2.push_back(1);
    d2.push_back(2);
    d2.push_back(3);

    d1.insert(d1.begin(), d2.begin(), d2.end());
    printDeque(d1);                        //1 2 3 10000 10000 1000 200 100 10 20
}

void test3()
{
    deque<int>d1;
    d1.push_back(10);
    d1.push_back(20);
    d1.push_front(100);
    d1.push_front(200);

    //删除
    deque<int>::iterator it = d1.begin();
    it++;
    d1.erase(it);
    //200 100 10 20
    printDeque(d1);        //200 10 20

    //按区间方式清空
    d1.erase(d1.begin(), d1.end());
    printDeque(d1);        //打印一行空白
    //清空
    d1.clear();
    printDeque(d1);        //打印一行空白
}

int main()
{
    //test1();
    //test2();
    test3();

    system("pause");
    return 0;
}

 

3.3.6  deque数据存取

 

 功能描述：对deque中的数据的存取操作

函数原型：

at(int idx);　　　　//返回索引idx所指的数据

operator[ ];　　　　//返回索引idx所指的数据

front();　　　　　　//返回容器中第一个数据元素

back();　　　　　　//返回容器中最后一个元素数据

#include<iostream>
using namespace std;
#include<deque>

//deque数据存取

void test1()
{
    deque<int>d;
    d.push_back(10);
    d.push_back(20);
    d.push_back(30);
    d.push_front(100);
    d.push_front(200);
    d.push_front(300);        


    //通过[]方式访问元素
    for (int i = 0; i < d.size(); i++)
    {
        cout << d[i] << " ";        //300 200 100 10 20 30
    }
    cout << endl;

    //通过at方式访问元素
    for (int i = 0; i < d.size(); i++)
    {
        cout << d.at(i) << " ";        //300 200 100 10 20 30
    }
    cout << endl;

    cout << "第一个元素为：" << d.front() << endl;        //300
    cout << "最后一个元素：" << d.back()  << endl;        //30
}



int main()
{
    test1();

    system("pause");
    return 0;
}

除了使用迭代器获取deque容器中的元素，[]和at也可以；

 

3.3.7  deque排序

功能描述：利用算法实现对deque容器进行排序；

算法：sort（iterator beg，iterator end）；　　　　//对beg和end区间内元素进行排序

#include<iostream>
using namespace std;
#include<deque>
#include<algorithm>        //标准算法头文件

void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}
//deque数据存取
void test1()
{
    deque<int>d;
    d.push_back(10);
    d.push_back(20);
    d.push_back(30);
    d.push_front(100);
    d.push_front(200);
    d.push_front(300);        
    
    printDeque(d);                //300 200 100 10 20 30

    //排序 默认排序规则   从小到大 升序
    //对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
    //vector容器也可以利用sort进行排序

    sort(d.begin(), d.end());
    cout << "排序后：" << endl;            
    printDeque(d);                //10 20 30 100 200 300
}

int main()
{
    test1();

    system("pause");
    return 0;
}

总结：sort算法非常实用，使用时包含头文件algorithm即可。