C++.STL.deque基本信息

目录

四.STL.deque

  4.1 deque 容器基本概念

  4.2 deque 容器内部工作原理

  4.3 deque 构造函数

  4.4 deque 赋值操作

  4.5 deque 大小操作

  4.6 deque 插入和删除

   4.7 deque 数据存取

   4.8 deque 排序

---

四.STL.deque

  4.1 deque容器基本概念

  4.2 deque容器内部工作原理

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

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

  4.3 deque构造函数

        函数原型：

• deque<type>name_a;   //默认构造函数
• deque<begin, end>;  //构造函数将[beg，end]区间中的元素拷贝给本身
• deque<n, element>;  //构造函数将n个elem拷贝给本身
• deque<const deque &deque_name>;  //拷贝构造函数

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

//deque构造函数
void println(const deque<int>&d)//加const限定只读状态，相应的也要变成const_iterator
{
    for(deque<int>::const_iterator it = d.begin() ; it!=d.end() ; it++)
    {
//        *it = 100;         const-》容器中数据不可修改
        cout<< *it << "  ";
    }
    cout<<endl;
}

void test01()
{
    deque<int>d1;
    for(int i=0;i<10;i++)
        d1.push_back(i);
    println(d1);

    deque<int>d2(d1.begin(),d1.end());
    println(d2);

    deque<int>d3(10,100);    //输出10个100
    println(d3);

    deque<int>d4(d3);
    println(d4);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

        #queue容器和vector容器的构造方式几乎都一样

  4.4 deque赋值操作

        函数原型：

• deque& operator = (const deque &deque_name);  //重载等号操作符
• assign(begin, end);  //将[begin， end]区间中的数据拷贝赋值给本身
• assign(n, element);  //将n个element拷贝赋值给本身

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

void println(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);
    }
    println(d1);
    //等号赋值operator=
    deque<int>d2;
    d2=d1;
    println(d2);
    //assign赋值
    deque<int>d3,d4;
    d3.assign(d1.begin(),d1.end());
    d4.assign(10,100);          //输出10个100
    println(d3);
    println(d4);
}

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

        #构造函数和赋值函数很像，怎么区分呢

  4.5 deque大小操作

        函数原型：

• deque.empty();  //判断容器是否为空
• deque.size();  //返回容器中元素的个数
• deque.relize(num);  //重新指定容器的长度num。若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出的部分被删除。
• deque.relize(num,element);  //重新指定容器的长度num。若容器变长，则以element填充新位置；如果容器变短，则末尾超出的部分被删除。

        #vector内存空间时连续的，deque内存空间不是连续的

  4.6 deque插入和删除

        函数原型：

• 两端插入删除：

1. push_back(element);
2. push_front(element);
3. pop_back();
4. pop_front();

• 指定位置插入删除：

1. insert(pos, elem);  //在pos位置插入一个elem元素的拷贝，返回新数据位置
2. insert(pos, n, elem);  //在pos位置插入n个elem数据，无返回值
3. insert(pos, begin, end);  //在pos位置插入【begin, end】区间的数据，无返回值
4. clear();  //清除所有数据
5. erase(begin, end);  //删除【begin, end】区间的数据，返回下一个数据的位置
6. erase(pos);  //删除pos位置的数据，返回下一个数据的位置

#include "deque"
#include "iostream"
using namespace std;

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

void test01()
{
    deque<int>d1;
    //
    d1.push_back(1);
    d1.push_back(3);
    d1.push_front(5);
    d1.push_front(7);
    println(d1);
    //
    d1.pop_back();
    d1.pop_front();
}

void test02()
{
    deque<int>d2;
    d2.push_front(1);
    d2.push_front(2);
    d2.push_back(4);
    d2.push_back(5);
    println(d2);
    //
    d2.insert(d2.begin(),1000);
    d2.insert(d2.begin(),2,100);
    println(d2);
    //
    deque<int>d3;
    d3.push_front(1);
    d3.push_front(2);
    d3.push_back(4);
    d3.push_back(5);
    d3.insert(d3.end(),d2.begin(),d2.end());
    println(d3);
}

void test03()
{
    deque<int>d4;
    d4.push_front(1);
    d4.push_front(2);
    d4.push_back(4);
    d4.push_back(5);
    println(d4);
    //
    d4.erase(d4.begin());
    println(d4);
    //
    d4.clear();
    println(d4);
}

int main()
{
    test01();
    test02();
    test03();
    return 0;
}

   4.7 deque数据存取

        函数原型：

• at(int index);  //返回索引index所指的数据
• operator[ ];  //返回索引index所指的数据
• front();  //返回容器中第一个元素
• back();  //返回容器中最后一个数据元素

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

//deque容器的数据存取
void test01()
{
    deque<int>d1;
    d1.push_back(1);
    d1.push_back(2);
    d1.push_back(3);
    d1.push_back(4);
    //通过【】方式访问元素
    for(int i=0;i<d1.size();i++)
        cout<<d1[i]<<" ";
    cout<<endl;
    //通过at访问元素
    for(int i=0;i<d1.size();i++)
        cout<<d1.at(i)<<" ";
    cout<<endl;
    //访问头尾元素
    cout<<d1.front()<<" , "<<d1.back()<<" ";
}

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

  4.8 deque排序

        算法：

sort(iteartor begin, iterator end);  //对begin和end区间内的元素进行排序

        #对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序，vector容器也可以利用sort进行排序

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

void println(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(1);
    d1.push_back(5);
    d1.push_back(6);
    d1.push_back(3);
    println(d1);
    //排列 从小到大
    sort(d1.begin(),d1.end());
    println(d1);

}

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