C++中的deque容器

deque容器基本概念

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

deque与vector区别：

• vector对于头部的插入删除掉率低，数据量越大，效率越低
• deque相对而言，对头部的插入删除速度会比vector快
• vetcor访问元素时的速度会比deque快，这和两者内部的实现有关

deque工作原理：

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

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

• deque容器中的迭代器也是支持随机访问的。

deque构造函数

功能描述

• deque容器构造

函数原型：

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

deque（beg，end）；//构造函数将【beg，end）区间中的元素拷贝给本身

deque（n，ele）； //构造函数将n个elem拷贝给本身

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

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

//一般的话会在deque前面加上一个const表明我这个容器只能够读，不能够进行修改
void printDeque(const deque<int> &d)
{
    for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

//deque构造函数
void test01()
{
    deque<int> d1;//默认构造函数
    for(int i=0;i<10;i++)
    {
        d1.push_back(i); //向队列尾部添加元素
        d1.push_front(i+10);//向队列头部插入元素
    }
    printDeque(d1);

    deque<int> d2(d1.begin(),d1.end());//区间构造函数
    printDeque(d2);

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

    deque<int> d4(d2);//拷贝构造函数
    printDeque(d4);
}

int main()
{
    test01(); //测试deque的构造函数
    return 0;
    

}

deque容器赋值操作

功能描述：

• 给deque容器赋值

函数原型

deque& operator=（const deque &deq）；//重载等号操作符

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

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

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


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

//deque容器的赋值操作
void test01()
{
    deque<int> d1;
    for(int i=0;i<10;i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);

    //operator=赋值
    deque<int> d2;
    d2=d1;
    printDeque(d2);

    //assign赋值
    deque<int> d3;
    d3.assign(d1.begin(),d1.end());
    printDeque(d3);

    deque<int> d4;
    d4.assign(10,100);
    printDeque(d4);

}

int main()
{
    test01();
    return 0;

}

因此deque赋值操作跟vector相同，需熟练掌握。

deque容器大小操作

功能描述：对deque容器的大小进行操作

函数原型

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

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

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

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

在deque容器中是没有容量的限制的，它可以在后面无限制的扩充新的容量区域。

#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++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

//deque容器的一个大小操作
void test01()
{
    deque<int> d1;

    for(int i=0;i<10;i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);

    if(d1.empty())
    {
        cout<<"d1 is empty"<<endl;
    }
    else
    {
        cout<<"di is not empty"<<endl;
        cout<<"d1 size: "<<d1.size()<<endl;  
        //deque容器没有容量概念，因此其数据可以无限的往里面去放，这跟其内部的结构有关系
    }
    //重新制定其大小
    //d1.resize(15);
    //printDeque(d1);

    //假如不想用0来填充
    d1.resize(15,1);
    printDeque(d1);

    d1.resize(5);
    printDeque(d1);


}


int main()
{
    test01();

}

deque插入和删除

功能描述：向deque容器中插入和删除数据

函数原型：

push_back(elem);  //向容器尾部添加一个数据

push_front(elem); //向容器头部添加一个数据

pop_back();       //删除容器最后一个数据

pop_front();      //删除容器第一个数据

指定位置操作

insert(pos,elem);  //在pos位置插入一个elem元素的拷贝，返回新数据的位置

insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值

insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值

clear();            //清空容器内的所有数据

erase(beg,end);  //删除[beg,end)区间的数据，返回下一个数据的位置

erase(pos);//删除pos位置的数据，返回下一个数据的位置

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


void print_Deque(const deque<int> &d)
{
    for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
    {
        cout << *it << " ";
    }
    cout<<endl;

}
//deque容器的插入和删除
void test01()
{
    //对于两端进行操作
    deque<int> d1;
    d1.push_back(10);//往尾部插入元素
    d1.push_back(20);

    //头插
    d1.push_front(100);//往头部插入元素
    d1.push_front(200);

    print_Deque(d1);
    //尾删
    d1.pop_back();
    d1.pop_front();
    print_Deque(d1);

}

//对于指定的位置进行一个插入和删除
void test02()
{
    deque<int> d2;
    d2.push_back(10);
    d2.push_back(20);
    d2.push_front(100);
    d2.push_front(200);

    print_Deque(d2);

    //利用insert方式来进行插入
    d2.insert(d2.begin(),1000);
    print_Deque(d2);

    d2.insert(d2.begin(),2,10000);
    print_Deque(d2);

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

    d2.insert(d2.begin(),d3.begin(),d3.end());
    print_Deque(d2);
}

//删除
void test03()
{
    deque<int> d4;
    d4.push_back(10);
    d4.push_back(20);
    d4.push_front(100);
    d4.push_front(200);

    print_Deque(d4);

    // d4.erase(d4.begin());
    // print_Deque(d4);
    //或者是说删除其他位置的元素
    deque<int>::iterator it=d4.begin();
    it++;
    d4.erase(it);
    print_Deque(d4);

    //按照区间的方式删除
    d4.erase(d4.begin(),d4.end());
    print_Deque(d4);
    //还有一个成员函数是专门用来清空的
    d4.clear();
    print_Deque(d4);

}


int main()
{
        test03();

}

插入删除提供的位置是迭代器。

deque数据存取操作

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

函数原型

at（int idx）； //返回索引值idx所指的数据

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

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

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

#include <iostream>
using namespace std;
//deque容器的数据存取操作
#include <deque>


void test01()
{
    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);

    //此时我们不用迭代器了，而是利用[]方式访问元素
    //300,200,100,10,20,30
    for(int i=0;i<d.size();i++)
    {
        cout<<d[i]<<" ";
    }
    cout<<endl;
    //通过at的方式来访问元素
    for(int i=0;i<d.size();i++)
    {
        cout<<d.at(i)<<" ";
    }
    cout<<endl;

    //访问头尾元素
    cout<<"头元素："<<d.front()<<endl;
    cout<<"尾元素："<<d.back()<<endl;

}


int main()
{
    test01();

}

deque排序

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

算法：

sort(iterator beg,iterator end)//对beg和end区间内元素进行排序

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

void print_Deque(const deque<int> &d)
{
    for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}


//deque容器排序
void test01()
{
    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);

    print_Deque(d);

    //排序操作
    //对于支持随机访问的迭代器的容器，都可以利用sort算法来进行排序
    //vector容器也可以利用sort算法来进行排序
    sort(d.begin(),d.end());
    cout<<"排序后的结果："<<endl;
    print_Deque(d);
}

int main()
{
    test01();

}

案例-评委打分

有五名选手：选手ABCDE，10个评委分别对每一名选手进行打分，去除最高分，去除评为中最低分，取平均分。

实现步骤：

• 创建五名选手，放到vector中
• 遍历vector容器，取出每一个选手，执行for循环，可以吧10个评分打分存到deque容器中（因为deque容器对于头端和尾端的操作比较方便）
• sort算法对deque容器中分数排序，取出最高和最低分
• deque容器遍历一遍，累计总分
• 获取平均分

#include <iostream>
using namespace std;
#include <vector>
#include <deque>
#include <algorithm>
#include <string>


//选手类
class Person{
    public:
    Person(string name,int score)
    {
        this->m_Name=name;
        this->m_Score=score;
    }
    string m_Name;//姓名
    int m_Score;//分数

};


void creatPerson(vector<Person> &v)
{
    string nameSeed="ABCDE";
    for(int i=0;i<5;i++)
    {
        string name="选手";
        name+=nameSeed[i];

        int score=0;

        Person p(name,score);
        //将创建的Person对象放入到容器中
        v.push_back(p);
    }
}

void setScore(vector<Person> &v)
{
    for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
    {
        //将评委的分数放入到deque容器中
        deque<int> d;
        for(int i=0;i<10;i++)
        {
            int score=rand()%41+60;  //60~100
            d.push_back(score);
        }

        //输出每一个评委给他打的分数
        // cout<<it->m_Name<<"打分： "<<endl;
        // for(deque<int>::iterator dit=d.begin();dit!=d.end();dit++)
        // {
        //     cout<<*(dit)<<" ";
        // }
        // cout<<endl;

        //排序
        sort(d.begin(),d.end());

        //去除一个最高和最低分
        d.pop_back();
        d.pop_front();

        //取平均分
        int sum=0;
        for(deque<int>::iterator dit=d.begin();dit!=d.end();dit++)
        {
            sum+=*(dit);
        }
        int average_Score=sum/d.size();

        //将平均分赋值给选手
        it->m_Score=average_Score;
    }
}
void showScore(vector<Person> &v)
{
    for(vector<Person>::iterator pit=v.begin();pit!=v.end();pit++)
    {
        cout<<"姓名： "<<pit->m_Name<<" 平均分："<<pit->m_Score<<endl;

    }
}

int main()
{
    //1.创建5名选手
    vector<Person> v;//存放选手的容器
    
    creatPerson(v);

    //测试
    // for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
    // {
    //     cout<<"姓名:"<<(*it).m_Name<<" 分数:"<<(*it).m_Score<<" ";
    // }
    //2.给5名选手打分
    setScore(v);
    //3.显示最后的得分
    showScore(v);

}