C++Vector和deque容器

vector

vector是STL中最常用的一种数据结构

特点：

• 与数组类似，但是数组是固定长度，vector是长度可变的，可以动态扩展的。

• 支持随机访问

• 

• 动态扩展并不是在原有的空间进行扩展，而是新建一个比原来更大的空间，空间的大小由vector内部的算法确定

vector的构造函数

• vector v;用类模板实现，默认构造函数
• vector(v.begin(), v.end());将一个v[v.begin(),v.end())前闭后开的区间的内容给vector，
• vector(n,elem);将n个elem给vector
• vector(const vector& v);拷贝构造函数

#include 
#include 
using namespace std;

void printVector(vector<int>&v)
{
    for(const int & n : v)
    {
        cout<<n<<" ";
    }
    cout<<endl;
}
void test01()
{
    vector<int> v1;//默认构造
    for(int i=0;i<10;i++)
    {
        v1.push_back(i);
    }
    cout<<"v1"<<endl;
    printVector(v1);

    vector<int> v2(v1.begin(),v1.end());//将v1迭代器区间的内容给v2
    cout<<"v2"<<endl;
    printVector(v2);

    vector<int> v3(10, 'a');//n个elem
    cout<<"v3"<<endl;
    printVector(v3);

    vector<int> v4(v3);//拷贝构造
    cout<<"v4"<<endl;
    printVector(v4);
}

int main()
{
    test01();
}

vector赋值

函数原型：

• vector& operator=(const vector& v);//重载=操作符
• assign(v.begin(),v.end());将左闭右开区间[begin,end)赋值给本身
• assign(n,elem);将n个elem赋值给本身

示例：

void test01()
{
    vector v1;
    for(int i=0;i<10;i++)
    {
        v1.push_back(i);
    }
    vector v2 = v1;//等号操作符进行赋值

    vector v3;//将左闭右开区间赋值给本身
    v3.assign(v1.begin(),v1.end());

    vector v4;
    v4.assign(10,1);//n个elem

}

vector容器的容量和大小

函数原型

• empty()判断容器是否为空
• capacity()容器的容量,vector容器的容量会比存放的数据多一点
• size()容器中元素的个数
• resize(int num)，重新指定容器的大小，如果容器变长，原数据填充原位置，若变短，则超出容器范围的数据被删除
• resize(innt num,elem)重新指定容器的大小，如果容器变长，原数据填充原位置，以elem填充原位置，若变短，则超出容器范围的数据被删除

void test01()
{
    vector v1;
    for(int i=0;i<10;i++)
    {
        v1.push_back(i);
    }
    cout<<"v1是否为空"<

vector的插入和删除

函数原型

• push_back(elem)尾部插入元素
• pop_back()删除最后一个元素
• insert(const_iterator pos,elem)迭代器向指定位置pos插入元素elem
• insert(const_iterator pos,int count,elem)向指定位置插入count个elem
• erase(const_iterator pos)删除指定位置元素
• erase(const_iterator begin,const_iterator end)删除从begin到end的元素
• clear()删除元素中所有的元素

vector数据的存取

函数原型

• at(int index)获取index位置的元素
• operator[int index]获取index处的元素
• front()获取第一个元素
• back()获取最后一个元素

vector互换容器

函数原型

• swap(vector& v)容器本身与容器v互换

作用1：收缩内存

void test01()
{
    vector v;
    for (int i = 0; i < 10000; ++i) {
        v.push_back(i);
    }
    cout<<"v的容量"<(v).swap(v);

    cout<<"交换后v的容量"<

vector预留空间

作用：提前预留空间，减少动态扩展容量时的扩展次数

函数原型

• reserve(int len)预留len个空间

​

reserve只预留空间不初始化数据

如果vector要存放的数据比较多，可以直接预留足够的空间，不用一次次地动态扩展，影响性能

void test01()
{
    vector<int> v;

    int num = 0;
    int *p = nullptr;
    for (int i = 0; i < 10000; ++i) {
        v.push_back(i);
        if(p!=&v[0])
        {
            p = &v[0];
            num++;
        }
    }
    cout<<"v1动态扩展的次数:"<<num<<endl;


    vector<int> v2;
    int num2 = 0;
    int *p2 = nullptr;
    v2.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        v.push_back(i);
        if(p!=&v.at(0))
        {
            p = &v.at(0);
            num2++;
        }
    }
    cout<<"v2动态扩展的次数:"<<num2<<endl;
}

deque容器

deque是一个双端数组，可对头端进行插入

deque与vector的区别：

• deque的头部插入比vector快
• deque的访问速度不如vector

deque内部原理：

构造函数

函数原型：

• deque deqT;默认构造
• deque(beg,end);
• deque(n, elem);
• deque(const deque& deq);

deque赋值

与vector类似

函数原型：

• deque& operator=(const deque& deq);
• assign(begin,end);
• assign(n,elem);

deque大小

函数原型：

• deque.empty();判断容器是否为空
• deque.size();返回容器中元素的个数
• deque.resize(num);重新指定容器长度为num，容器变长以0填充，容器变短，超出部分被删除
• deque.resize(num, elem);重新指定容器长度为num，容器变长以elem填充，容器变短，超出部分被删除

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, begin,end);在pos位置插入[begin,end)区间的数据，无返回值
• clear();清空容器
• erase(begin, end);删除[begin,end)区间的数据，返回邪恶一个数据的位置
• erase(pos);删除pos位置的数据，返回下一个数据的位置

deque数据存取

函数原型：

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

deque排序操作

利用算法实现deque内部数据的排序

#include

函数原型：

• sort(iterator begin,iterator end);对beg,end区间内的元素进行排序

void test01()
{
    deque deq;
    deq.push_back(10);
    deq.push_back(20);
    deq.push_back(30);
    deq.push_front(100);
    deq.push_front(200);
    deq.push_front(300);
    //300 200 100 10 20 30
    printDeque(deq);
    sort(deq.begin(),deq.end());
    printDeque(deq);//10 20 30 100 200 300
}