STL后续-deque容器

最新推荐文章于 2024-11-16 10:02:08 发布
最新推荐文章于 2024-11-16 10:02:08 发布
阅读量85 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55610255/article/details/133235568
版权

前期简介：STL的六个组件

容器（container）：一种空间，用来存放数据，可以分为连续空间和非连续空间

算法（algorithm）：用来操作数据

迭代器（iterator）：泛化的指针，用来指向容器中的某个位置便于算法间接的操作数据

仿函数（functor）:又叫函数对象，即重载了函数调用运算符的类其实例化的对象，为算法提供策略（抛开函数调用来操作数据外，还可以使用仿函数来调用数据）

适配器（adaptor）：为一个类模板，用于接口映射

空间配置器（allocator）：为容器分配所需要大小的空间

容器的分类

STL标准模板库提供了很多容器，总体分为两种容器，序列容器（sequence containers）和关联容器(associative containers)

常见的序列容器有vector、deque、queue、stack、list，

常见的关联容器有set、multiset、map、multimap。
上章节讲到了vector容器，这章节详细的讲一下deque容器

deque

deque区别于vector，他是双端动态数组(双端队列)，即可以两端操作，

 deque的特点

1、deque容器允许以常数项时间对头尾两端进行操作，比如插入删除操作

2、deque容器没有容量的概念（capacity），因为deque的容器是分段连续的空间，可以理解为多个vector且头尾都可以操作的空间集合（不严谨），有图示下：

此图可知：这个缓冲区每一行可以理解为一个vector，每个vector通过中控器相连在一起形成一个deque容器，类似于链表（链表中的每一个节点通过指针相连）

deque的API

/*
 * deque的构造函数
 * deque<T> deque;//默认构造函数
 * deque(begin,end);//将[begin,end)区间的数据拷贝给自己,不能这样初始化，可以使用insert(deque,begin,end);
 * deque(num,element);//将num个element数据拷贝给自己,调用不适用，可以使用deque(deque.end(),num,element);
 * deque(cons deque &deque);//拷贝构造函数，在deque不适合用()，可以使用=,即deque(自己)=deque;
 *
 * deque的赋值操作
 * assign(begin,end);//通过调用assign方法将[begin,end)区间的数据拷贝给自己
 * assign(num,element);//通过调用assign方法将num个element数据拷贝给自己
 * deque& opeerator=(const deque &deque);//重载赋值运算符，将deque对象拷贝赋值给自己
 * swap(deque);//调用swap方法将deque对象的数据和自己的数据互换
 *
 * deque空间操作
 * deque.size();//返回容器中的元素个数
 * deque.empty();//判断容器是否为空，为空则返回true,不为空返回false
 * deque.resize(num);//重新指定容器的长度为num,若容器变长，比原来长的部分空间以默认值填充(一般是0)，若容器变短，则超出的部分元素被删除
 * deque.resize(num,element);//重新指定容器的长度为num，若容器变长，比原来长的部分空间以指定的element填充，若容器变短，则超出的部分元素被删除
 *
 * deque的双端队列插入和删除操作
 * push_bakc(element);//尾部插入一个element数据
 * push_front(element);//在头部插入一个element数据
 * pop_back();//没有参数，调用一次pop_back方法则表示删除容器尾部最后一位元素
 * pop_front();//也没有参数，调用一次pop_front方法则表示删除容器头部第一个元素
 *
 */

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

//自定义一个遍历deque容器的方法
void printDequeInt(deque<int> &d){
    deque<int>::iterator it=d.begin();
    for(;it!=d.end();it++){
        //*it表示取值，即*it==int(某一个值)
        cout<<*it<<" ";
    }
    cout<<endl;//容器内所有数据遍历之后输出换行
}

void test(){
/*
 * deque的构造函数
 * deque<T> deque;//默认构造函数
 * deque(begin,end);//将[begin,end)区间的数据拷贝给自己,不能这样初始化，可以使用insert(deque,begin,end);
 * deque(num,element);//将num个element数据拷贝给自己,调用不适用，可以使用deque(deque.end(),num,element);
 * deque(cons deque &deque);//拷贝构造函数，在deque不适合用()，可以使用=,即deque(自己)=deque;
 *
 * deque的赋值操作
 * assign(begin,end);//通过调用assign方法将[begin,end)区间的数据拷贝给自己
 * assign(num,element);//通过调用assign方法将num个element数据拷贝给自己
 * deque& opeerator=(const deque &deque);//重载赋值运算符，将deque对象拷贝赋值给自己
 * swap(deque);//调用swap方法将deque对象的数据和自己的数据互换
 *
 * deque空间操作
 * deque.size();//返回容器中的元素个数
 * deque.empty();//判断容器是否为空，为空则返回true,不为空返回false
 * deque.resize(num);//重新指定容器的长度为num,若容器变长，比原来长的部分空间以默认值填充(一般是0)，若容器变短，则超出的部分元素被删除
 * deque.resize(num,element);//重新指定容器的长度为num，若容器变长，比原来长的部分空间以指定的element填充，若容器变短，则超出的部分元素被删除
 *
 * deque的双端队列插入和删除操作
 * push_bakc(element);//尾部插入一个element数据
 * push_front(element);//在头部插入一个element数据
 * pop_back();//没有参数，调用一次pop_back方法则表示删除容器尾部最后一位元素
 * pop_front();//也没有参数，调用一次pop_front方法则表示删除容器头部第一个元素
 *
 */

    //以int类型的deque容器为例，deque容器的双端队列插入操作
    deque<int> deq;
    deq.push_back(100);
    deq.push_back(300);
    deq.push_back(900);
    printDequeInt(deq);

    deq.push_front(1200);
    deq.push_front(2000);
    printDequeInt(deq);

    //deque容器的删除和空间操作
    cout<<deq.size()<<endl;//尾部删除前容器大小
    deq.pop_back();//调用尾部删除方法之后，尾部元素被删除
    cout<<deq.size()<<endl;//删除后容器大小
    printDequeInt(deq);

    cout<<deq.size()<<endl;//头部删除前容器大小
    deq.pop_front();
    cout<<deq.size()<<endl;//头部删除后容器大小
    printDequeInt(deq);

    if(deq.empty()){
        cout<<"容器为空"<<deq.size()<<endl;
        cout<<"尾部元素："<<deq.back()<<"头部元素："<<deq.front()<<endl;
    }
    else{
        cout<<"容器非空，大小为："<<deq.size()<<endl;
        cout<<"尾部元素："<<deq.back()<<"头部元素："<<deq.front()<<endl;
    }
   deq.resize(100);
   cout<<deq.size()<<endl;
   printDequeInt(deq);

   deq.resize(3);
   cout<<deq.size()<<endl;
   printDequeInt(deq);

   //deque的赋值操作
   deque<int> deq1;
   deq1.assign(deq.begin(),deq.end());
   cout<<deq.size()<<endl;
   printDequeInt(deq1);

   deq1.assign(9,9999);
   cout<<deq1.size()<<endl;
   printDequeInt(deq1);


   deque<int> deq2;
   cout<<deq2.size()<<endl;
   deq2.resize(100);
   deq2=deq1;
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);
   deq2.insert(deq2.end(),4,888);
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);
   deq2.insert(deq2.end(),deq1.begin(),deq1.end());
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);

   deq2.swap(deq1);
   cout<<"deq2的大小："<<deq2.size()<<" deq1的大小："<<deq1.size()<<endl;
   printDequeInt(deq2);
   printDequeInt(deq1);

   /*
   deque<int> deq2;
   cout<<deq2.size()<<endl;
   deq2.resize(100);
   deq2(deq1);
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);
   deq2(4,888);
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);
   deq2(deq1.begin(),deq1.end());
   cout<<deq2.size()<<endl;
   printDequeInt(deq2);

   deq2.swap(deq1);
   cout<<deq2.size()<<deq1.size()<<endl;
   printDequeInt(deq2);
   printDequeInt(deq1);
   */


}

int main()
{
    test();
    return 0;
}

输出结果：

tips:deq的构造函数不能直接对deq初始化

deque(begin,end);//将[begin,end)区间的数据拷贝给自己,不能这样初始化，可以使用insert(deque,begin,end);
 * deque(num,element);//将num个element数据拷贝给自己,调用不适用，可以使用deque(deque.end(),num,element);
 * deque(cons deque &deque);//拷贝构造函数，在deque不适合用()，可以使用=,即deque(自己)=deque;

deque的API (二)

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

//自定义一个遍历deque容器的方法
void printDequeInt(deque<int> &d){
    deque<int>::iterator it=d.begin();
    for(;it!=d.end();it++){
        //*it表示取值，即*it==int(某一个值)
        cout<<*it<<" ";
    }
    cout<<endl;//容器内所有数据遍历之后输出换行
}


}

void test1(){
    /*deque的数据存取
     * at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range
     * operator[idx];//越界不报错
     * front();//返回第一个数据
     * back();//返回最后一个数据
     *
     * deque的插入操作
     * insert(position,element);//在position位置上插入element元素
     * insert(position,n,element);//在position位置上插入n个element元素
     * inseret(position,begin,end);//在position位置上插入[begin,end)区间的元素
     *
     * deque的删除操作
     * clear();//删除所有数据
     * erase(begin，end);//删除[begin,end)区间的元素
     * erase(position);//删除position位置上的元素
     */
    deque<int> deq1;
    deq1.push_back(100);
    deq1.push_back(200);
    deq1.push_front(99999);
    printDequeInt(deq1);
    cout<<deq1.size()<<endl;

    for(unsigned int i=0;i<deq1.size();i++){
        cout<<deq1.at(i)<<" ";//越界抛出异常
        //cout<<deq1[i]<<" ";//越界不抛出异常

    }
    cout<<endl;
    deq1.insert(deq1.begin()+1,3,88888888);
    printDequeInt(deq1);
    cout<<deq1.size()<<endl;

    deq1.erase(deq1.begin());
    printDequeInt(deq1);
    cout<<deq1.size()<<endl;

    cout<<deq1.back()<<" "<<deq1.front()<<endl;

    for(unsigned int i=0;i<deq1.size()+1;i++){
        cout<<deq1.at(i)<<" ";//越界抛出异常
        //cout<<deq1[i]<<" ";//越界不抛出异常

    }
    cout<<endl;
}

int main()
{
    test1();
    return 0;
}

第一个输出结果：

第二个输出结果：

tips:根据结果可知，双端动态数组deq1调用at方法，如果数据访问越界，就会抛出异常，而以数组的方式则不会抛出异常（第二个输出结果）

vector容器和deque容器的应用：

案例：学校举办一场篮球比赛，有五名选手ABCDE，十个评委，每一个评委都会给这五名选手分别打分，去除最高分和最低分，取平均分为五名选手的最终得分，平均分最高的为冠军，第二名亚军，第三名季军。

设计方法：1、创建五名选手，放到vector容器

2、遍历vector容器，取出每一个选手让10名评委打分，10个评委打的分数放进deque容器

3、sort算法对deque容器的分数排序并用pop_back和pop_front方法去掉最高分和最低分

4、deque容器遍历一遍，累加分数/deque.size()，获取平均分

5、对每一个人的平均分比较，筛选出冠军、亚军、季军

案例输出：

#include <iostream>
#include<string>
#include<vector>
#include<time.h>
#include<deque>
#include<algorithm>

using namespace std;

class Person
{

    friend void playGame(vector<Person> &v);
    friend void showPersonScore(vector<Person> &v);
private:
    string name;
    double score;

public:
    Person() {}
    Person(string name,double score){
        this->name=name;
        this->score=score;

    }
};

void createPersonToVector(vector<Person> &v){
    string tmpName="ABCDE";
    int i=0;
    for(i=0;i<5;i++){
        string name="选手";
        name+=tmpName[i];
        v.push_back(Person(name,0.0));
    }

}

void playGame(vector<Person> &v){
    //设置随机数种子
    srand(time(NULL));
    //逐个选手参加比赛
    vector<Person>::iterator it=v.begin();
    for(;it!=v.end();it++){
        //设置deque容器，把10个评委打分放进去
        deque<int> d;
        int i=0;
        for(;i<10;i++){
            //使用rand方法产生随机数，模拟10个评委打分
            d.push_back(rand()%41+60);//限制分数最低60，最高100

        }
        //sort方法排序并去掉最低分和最高分
        sort(d.begin(),d.end());
        d.pop_back();
        d.pop_front();

        //accumulate方法求和
        int sum=accumulate(d.begin(),d.end(),0);
        //求平均分
        (*it).score=(double)sum/d.size();
    }

}

void showPersonScore(vector<Person> &v){


    sort(v.begin(),v.end(),[](const Person &a,const Person &b){
        return a.score>b.score;
    });
    //输出排序后的结果
    cout<<"冠军:"<<v[0].name<<",得分:"<<v[0].score<<endl;
    cout<<"亚军:"<<v[1].name<<",得分:"<<v[1].score<<endl;
    cout<<"季军:"<<v[2].name<<",得分:"<<v[2].score<<endl;

    //遍历所有选手和得分结果
    cout<<"所有选手和得分公示结果如下:"<<endl;
    vector<Person>::iterator it=v.begin();
    for(;it!=v.end();it++){
        cout<<"选手:"<<(*it).name<<",得分:"<<(*it).score<<endl;
    }
}

int main()
{
    //将五名选手放进vectr容器
    vector<Person> v;
    createPersonToVector(v);
    //五名选手参加比赛
    playGame(v);
    //遍历选手成绩
    showPersonScore(v);
    return 0;
}

执行第一次程序，使用随机数输出结果：

执行第二次程序，使用随机数输出结果：

tips:每一次输出的结果是随机的，这里的随机是依赖srand和rand方法,严格来说不算真正的随机，只能是模拟随机

总结：

vector容器和deque容器的区分点：

1、vector 单端动态数组 空间连续，deque 双端动态数组 空间分段连续

2、vector 有容量的概念 deque容器没有容量的概念

3、vector 一端操作数据，deque双端操作数据（常数项时间）

4、vector和deque都是随机访问迭代器

tips:合适的场景选用合适的容器，才是最佳的选择，而不是选择一个你所擅长的容器或者你所喜欢的容器

凢曐
关注
C++ STL教程-deque用法详解
qq_33287871的博客
07-20 442
创建deque容器的几种方式 创建deque容器的几种方式) 创建deque容器的几种方式迭代器用法详解) 创建deque容器的几种方式添加和删除元素方法完全攻略) 创建deque容器的几种方式添加和删除元素方法完全攻略) deque 是 double-ended queue 的缩写，又称双端队列容器。 前面章节中，我们已经系统学习了 vector 容器，值得一提的是，deque 容器和 vector 容器有很多相似之处，比如： deque 容器也擅长在序列尾部添加或删除元素（时间复杂度为O(1)），而不擅
C++(STL):17---deque之迭代器使用
网易搬砖选手
12-16 776
deque 容器迭代器的类型为随机访问迭代器，deque 模板类提供了表 1 所示这些成员函数，通过调用这些函数，可以获得表示不同含义的随机访问迭代器。表 1deque 支持迭代器的成...
stl标准库系列之--deque
slowlytalk
04-21 667
1、概述 deque 是 double-ended queue 的缩写，又称双端队列容器。是由一段一段的定量连续空间构成，可以向两端发展，因此不论在尾部或头部安插元素都十分迅速。 在中间部分安插元素则比较费时，因为必须移动其它元素。 我们看下deque的示意图。 2、与vector的区别 vector是单向开口的连续性空间，deque则是双向开口的连续空间（连续是假象）。 deque 容器也擅长在序列尾部添加或删除元素（时间复杂度为O(1)），而不擅长在序列中间添加或删除元素。 vector扩容时经历了
STL后续-stack容器
qq_55610255的博客
10-29 55
stack容器是一种栈容器说到栈，大家就想起来了栈的一个最特别的规则--->先进后出stack容器他也是一个先进后出（FILO）的数据结构，只有一个出口。
3-4-2 deque 容器的迭代器用法
chumingqian的博客
04-27 1318
eque 容器迭代器的类型为随机访问迭代器，deque 模板类提供了表 1 所示这些成员函数，通过调用这些函数，可以获得表示不同含义的随机访问迭代器。 有关迭代器及其类型的介绍，可以阅读《C++ STL迭代器（iterator）》一节，本节不再做具体介绍。 表 1 deque 支持迭代器的成员函数 成员函数 功能 begin() 返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。 end() 返回指向容器最后一个元素之后一个位置的
3-4-1 deque 容器介绍
chumingqian的博客
04-27 543
deque 是 double-ended queue 的缩写，又称双端队列容器。 前面章节中，我们已经系统学习了 vector 容器，值得一提的是，deque 容器和 vecotr 容器有很多相似之处，比如： deque 容器也擅长在序列尾部添加或删除元素（时间复杂度为O(1)），而不擅长在序列中间添加或删除元素。 deque 容器也可以根据需要修改自身的容量和大小。 和 vector 不同的是，deque 还擅长在序列头部添加或删除元素，所耗费的时间复杂度也为常数阶O(1)。并且更重要的一点是，deque
【deque容器系列一】基于STL源码分析deque容器整体实现及内存结构
cpp加油站的专栏
07-14 350
本篇文章基于gcc中stl的源码介绍deque容器的整体实现和它的内存结构。 说明一下，我用的是gcc7.1.0编译器，标准库源代码也是这个版本的。 首先呢，还是看一下思维导图，如下： 1. deque容器整体源码实现介绍 deque容器是stl中顺序容器的一种，之前已经介绍过array和vector了，今天介绍deque容器，deque的本质是一个类模板，它的声明位于头文件bits/stl_deque.h，实现位于bits/deque.tcc，接下来我们就围绕这两个文件来介绍一下deque容器的实现
STL deque容器
weixin_51196603的博客
04-05 2265
STL中的容器： deque容器的常用接口及用法： deque：它被称作双端数组，可以在头部和尾部插入或删除数据； deque 容器和 vector 容器的区别： 1.vector 容器对头部插入、删除数据的效率较低，因为 vector 容器是单端数组，若要从头部插入或删除，得把后面的数据都往后挪或往前挪，因此数据量越大，则其时间效率越低； 2.deque 容器相对 vector 容器而言，它对于头部插入数据或头部删除数据的效率就高多了，这与它的内部实现相关； 3.vector 容器访问单个数据的效率要
STL-常用容器
weixin_46934960的博客
11-19 1050
STL-常用容器 1、string容器 1.1 string基本概念 本质： string是C++风格的字符串，而string本质上是一个类 1.2 string构造函数 构造函数原型： string(); //创建一个空的字符串 string(const char* s); //使用字符串s初始化 string(const string& str)) //使用一个string对象初始化另一个string对象 str
C++ | STL deque容器
ThinPikachu的博客
03-17 1206
一.简述deque容器 deque是一个双端队列容器，其在低端为一个双端队列，所需要的头文件为#include<deque>。 正如上图所示，双端队列的每一个端口都既能出，又能进。但我们一般在使用双端队列时，使用的都是受限的双端队列，即我们选定双端队列的某一端只能进（插）元素，相反的，另一端就只能出元素。 deque的底层是双端队列，所以底层的内存空间是连续的，因此我们可...
【deque容器系列二】基于STL源码分析deque容器插入和删除时内存都是怎么变动的
cpp加油站的专栏
07-16 439
上篇文章我们介绍了deque容器整体结构和构造实现，链接如下： 基于STL源码分析deque容器整体实现及内存结构 本篇文章接上篇，继续基于gcc中stl的源码剖析deque容器插入、删除、取值的实现原理，以提问者的角度去深入分析这些操作过程中发生了什么，并对deque容器适合使用的场景和使用时的注意事项进行说明。 说明一下，我用的是gcc7.1.0编译器，标准库源代码也是这个版本的。 按照惯例，还是先看一下本文大纲，如下： 0. deque容器迭代器说明 在正式开始讲述插入、删除等操作的实现前，我们
【C++】STL之适配器---用deque实现栈和队列
m0_63198468的博客
09-22 2545
本介绍了什么是适配器，deque，并且使用queue去实现了stack和queue，重点介绍了他们函数接口的使用，以及后面的stack和queue模拟实现。
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
最新发布
zhaoylzy的博客
11-16 896
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
2411C++,C++26反射示例
个人进步之路
11-13 965
2411C++,C++26反射示例
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 533
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
C++——智能指针
Wangx_wang的博客
11-12 972
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++ 中的string类
2201_75357870的博客
11-15 791
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 1023
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
快速上手STL中list的使用
知其然 知其所以然
11-13 665
【代码】快速上手STL中list的使用。
C++ STL入门：序列式容器详解
"序列式容器-STL入门讲义" 在编程领域，STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法，大大增强了C++的抽象能力和泛型编程能力。STL主要...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值