C++提高笔记（三）---STL容器（vector、deque）

最新推荐文章于 2024-07-15 15:17:48 发布

正直和知府

最新推荐文章于 2024-07-15 15:17:48 发布

阅读量2.1k

点赞数 47

分类专栏： C++ 文章标签： c++ 笔记开发语言学习算法

本文链接：https://blog.csdn.net/m0_46359434/article/details/136649514

版权

C++ 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

1、vector容器

1.1vector基本概念

功能：vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector容器的迭代器是支持随机访问的迭代器

1.2vector构造函数

功能描述：创建vector容器

函数原型：

vector<T> v;                //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v［begin(),end() )区间中的元素拷贝给本身
vector(n, elem);            // 构造函数将n个elem拷贝给本身
vector(const vector& vec);  //拷贝构造函数

#include <iostream>
using namespace std;
#include<vector>
//vector构造函数：
//vector<T> v;                //采用模板实现类实现，默认构造函数
//vector(v.begin(), v.end()); //将v［begin(),end() )区间中的元素拷贝给本身
//vector(n, elem);            // 构造函数将n个elem拷贝给本身
//vector(const vector& vec);  //拷贝构造函数

void printVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector<int>v1;//默认构造，无参构造
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    printVector(v1);
    
    //通过区间方式进行构造
    vector<int>v2(v1.begin(), v1.end());
    printVector(v2);

    //n个elem方式构造
    vector<int>v3(6, 100);
    printVector(v3);

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

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

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
100 100 100 100 100 100
请按任意键继续. . .

1.3vector赋值操作

功能描述：给vector容器进行赋值

函数原型：

vector& operator=(const vector& vec); //重载等号操作符
assign(beg, end);                     //将［beg，end ) 区间中的数据拷贝赋值给本身
assign(n, elem);                      //将n个elem拷贝赋值给本身

#include <iostream>
using namespace std;
#include<vector>
//vector赋值操作：
//vector& operator=(const vector& vec); //重载等号操作符
//assign(beg, end);                     //将［beg，end ) 区间中的数据拷贝赋值给本身
//assign(n, elem);                      //将n个elem拷贝赋值给本身

void printVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector<int>v1;//默认构造，无参构造
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    printVector(v1);
    //赋值 operator=
    vector<int>v2;
    v2 = v1;
    printVector(v2);
    //assign赋值
    vector<int>v3;
    v3.assign(v1.begin(), v1.end());
    printVector(v3);
    //n个elem方式赋值
    vector<int>v4;
    v4.assign(10, 100);
    printVector(v4);
}

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

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100 100 100 100 100
请按任意键继续. . .

1.4vector容量和大小

功能描述：对vector容器的容量和大小操作

函数原型：

empty();                //判断容器是否为空
capacity();             //容器的容量
size();                 //返回容器中元素的个数
resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
                        //如果容器变短，则未尾超出容器长度的元素被删除
resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置
                        //如果容器变短，则未尾超出容器长度的元素被删除

#include <iostream>
using namespace std;
#include<vector>
// vector容器的容量和大小操作
//empty();                //判断容器是否为空
//capacity();             //容器的容量
//size();                 //返回容器中元素的个数
//resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//                        //如果容器变短，则未尾超出容器长度的元素被删除
//resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置
//                        //如果容器变短，则未尾超出容器长度的元素被删除

void printVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector<int>v1;//默认构造，无参构造
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    printVector(v1);

    if (v1.empty())//为真 代表容器为空
    {
        cout << "v1为空" << endl;
    }
    else
    {
        cout << "v1不为空" << endl;
        cout << "v1的容量为：" << v1.capacity() << endl;
        cout << "v1的大小为：" << v1.size() << endl;

        //重新指定大小
        //v1.resize(15);
        //printVector(v1);//若重新指定的容器变长了，默认用0填充新的位置
        //也可以指定默认填充值
        v1.resize(15,100);
        printVector(v1);

        v1.resize(5);//若重新指定的容器变短了，未尾超出容器长度的元素被删除
        printVector(v1);
    }
}

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

输出结果：

0 1 2 3 4 5 6 7 8 9
v1不为空
v1的容量为：13
v1的大小为：10
0 1 2 3 4 5 6 7 8 9 100 100 100 100 100
0 1 2 3 4
请按任意键继续. . .

1.5vector插入和删除

功能描述：对vector容器进行插入、删除操作

函数原型：

push_back(ele);                                  //尾部插入元素ele
pop_back();                                      //删除最后一个元素
insert(const_iterator pos, ele);                 //迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count, ele);      //送代器指向位置pos插入count个元系ele
erase(const_iterator pos);                       //删除迭代器指向的元素
erase(const_iterator start, const_iterator end); //删除选代器从start到end之间的元素
clear();                                         //删除容器中所有元素

#include <iostream>
using namespace std;
#include<vector>
//vector插入和删除

//push_back(ele);                                  //尾部插入元素ele
//pop_back();                                      //删除最后一个元素
//insert(const_iterator pos, ele);                 //迭代器指向位置pos插入元素ele
//insert(const_iterator pos, int count, ele);      //送代器指向位置pos插入count个元系ele
//erase(const_iterator pos);                       //删除迭代器指向的元素
//erase(const_iterator start, const_iterator end); //删除选代器从start到end之间的元素
//clear();                                         //删除容器中所有元素

void printVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector<int>v1;
    //尾插
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);
    //遍历
    printVector(v1);
    //尾删
    v1.pop_back();
    printVector(v1);
    //插入 第一个参数是迭代器
    v1.insert(v1.begin(), 100);
    printVector(v1);

    v1.insert(v1.begin(), 2, 90);
    printVector(v1);

    //删除 第一个参数是迭代器
    v1.erase(v1.begin());
    printVector(v1);
    //清空
    v1.clear();//与下句代码等价
    v1.erase(v1.begin(), v1.end());
    printVector(v1);
}

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

输出结果：

10 20 30 40 50
10 20 30 40
100 10 20 30 40
90 90 100 10 20 30 40
90 100 10 20 30 40

请按任意键继续. . .

1.6vector数据存取

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

函数原型：

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

#include <iostream>
using namespace std;
#include<vector>
//vector容器数据存取

//at(int idx);//返回索引idx所指的数据
//operator[]; //返回索引idx所指的数据
//front();    //返回容器中第一个数据元素
//back();     //返回容器中最后一个数据元素            
void test01()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    //利用[]方式访问数组中元素
    for (int i = 0; i < v1.size(); i++)
    {
        cout << v1[i] << " ";
    }
    cout << endl;
    //利用at方式访问数组中元素
    for (int i = 0; i < v1.size(); i++)
    {
        cout << v1.at(i) << " ";
    }
    cout << endl;
    //获取第一个元素
    cout << "第一个元素为: " << v1.front() << endl;
    //获取最后一个元素
    cout << "最后一个元素为: " << v1.back() << endl;
}

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

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
第一个元素为: 0
最后一个元素为: 9
请按任意键继续. . .

1.7vector互换容器

功能描述：实现两个容器内元素进行互换

函数原型：

swap(vec); //将vec与本身的元素互换

#include <iostream>
using namespace std;
#include<vector>
//vector容器互换
//swap(vec); //将vec与本身的元素互换   

//1、基本使用
void printVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    cout << "交换前：" << endl;
    printVector(v1);

    vector<int>v2;
    for (int i = 10; i > 0; i--)
    {
        v2.push_back(i);
    }
    printVector(v2);

    cout << "交换后：" << endl;
    v1.swap(v2);
    printVector(v1);
    printVector(v2);
}
//2、实际用途
//巧用swap可以收缩内存空间
void test02()
{
    vector<int>v;
    for (int i = 0; i < 100000; i++)
    {
        v.push_back(i);
    }
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
    v.resize(3);
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
    //巧用swap收缩内存空间
    //vector<int>(v)是一个匿名对象
    //.swap(v)做了一个容器之间的交换
    vector<int>(v).swap(v);
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
}

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

输出结果：

交换前：
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
交换后：
10 9 8 7 6 5 4 3 2 1
0 1 2 3 4 5 6 7 8 9
v的容量为：138255
v的大小为：100000
v的容量为：138255
v的大小为：3
v的容量为：3
v的大小为：3
请按任意键继续. . .

1.8vector预留空间

功能描述：减少vector在动态扩展容量时的扩展次数

函数原型：

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问

#include <iostream>
using namespace std;
#include<vector>
//vector预留空间
//reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问
void test01()
{
    vector<int>v;
    //利用reserve预留空间
    v.reserve(100000);//没有这句代码时，num = 30

    int num = 0;//统计开辟次数
    int* p = NULL;
    for (int i = 0; i < 100000; i++)
    {
        v.push_back(i);
        if (p != &v[0])
        {
            p = &v[0];
            num++;
        }
    }
    cout << "num = " << num << endl;
}

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

输出结果：

num = 1
请按任意键继续. . .

总结：如果数据量较大，可以一开始利用reserve预留空间

2、deque容器

2.1deque容器基本概念

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

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

deque内部工作原理：

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

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

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

2.2deque构造函数

功能描述：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>
//deque构造函数
//deque<T>deqT;            //默认构造形式
//deque(beg, end);         //构造函数将［beg, end）区间中的元素拷贝给本身
//deque(n, elem);          //构造函数将n个elem拷贝给本身
//deque(const deque& deq); //拷贝构造函数

void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //函数参数列表里的const和for循环条件里的const_把容器变为了只读状态
        //*it = 100;  容器中的数据不可以修改了
        cout << *it << " ";
    }
    cout << endl;
}

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

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

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

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

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

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
100 100 100 100 100 100
请按任意键继续. . .

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

2.3deque赋值操作

功能描述：给deque容器进行赋值

函数原型：

deque& operator=(const deque& deq); //重载等号操作符
assign(beg, end);                   //将［beg, end）区间中的数据拷贝赋值给本身
assign(n, elem);                    //将n个elem拷贝赋值给本身

#include <iostream>
using namespace std;
#include<deque>
//deque容器赋值操作
//deque& operator=(const deque& deq); //重载等号操作符
//assign(beg, end);                   //将［beg, end）区间中的数据拷贝赋值给本身
//assign(n, elem);                    //将n个elem拷贝赋值给本身
void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //函数参数列表里的const和for循环条件里的const_把容器变为了只读状态
        //*it = 100;  容器中的数据不可以修改了
        cout << *it << " ";
    }
    cout << endl;
}

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(6, 100);
    printDeque(d4);
}

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

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
请按任意键继续. . .

2.4deque大小操作

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

函数原型：

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

deque没有容量的概念

#include <iostream>
using namespace std;
#include<deque>
//deque容器大小操作
//deque.empty();                //判断容器是否为空
//deque.size();                 //返回容器中元素的个数
//deque.resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//                              //如果容器变短，则未尾超出容器长度的元素被删除
//deque.resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置
//                              //如果容器变短，则未尾超出容器长度的元素被删除
void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //函数参数列表里的const和for循环条件里的const_把容器变为了只读状态
        //*it = 100;  容器中的数据不可以修改了
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    deque<int>d1;
    for (int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }  
    if (d1.empty())
    {
        cout << "d1为空" << endl;
    }
    else
    {
        cout << "d1不为空" << endl;
        cout << "d1的大小为：" << d1.size() << endl;
        //deque没有容量的概念
    }
    printDeque(d1);
    //重新指定大小  变长
    d1.resize(12,1);
    printDeque(d1);
    //重新指定大小  变短
    d1.resize(5);
    printDeque(d1);
}

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

输出结果：

d1不为空
d1的大小为：10
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 1 1
0 1 2 3 4
请按任意键继续. . .

2.5deque插入和删除

功能描述：向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>
//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位置的数据，返回下一个数据的位置

void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //函数参数列表里的const和for循环条件里的const_把容器变为了只读状态
        //*it = 100;  容器中的数据不可以修改了
        cout << *it << " ";
    }
    cout << endl;
}
//两端操作
void test01()
{
    cout << "test01测试输出:" << endl;
    deque<int>d1;
    //尾插
    d1.push_back(10);
    d1.push_back(20);
    //头插
    d1.push_front(100);
    d1.push_front(200);
    //200 100 10 20
    printDeque(d1);
    //尾删
    d1.pop_back();
    printDeque(d1);
    //头删
    d1.pop_front();
    printDeque(d1);
}

void test02()
{
    cout << "test02测试输出:" << endl;
    deque<int>d1;
    //尾插
    d1.push_back(10);
    d1.push_back(20);
    //头插
    d1.push_front(100);
    d1.push_front(200);
    //200 100 10 20
    printDeque(d1);
    //insert 插入
    d1.insert(d1.begin(), 90);
    printDeque(d1);
    d1.insert(d1.begin(), 2, 80);
    printDeque(d1);
    //按照区间进行插入
    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);
}

void test03()
{
    cout << "test03测试输出:" << endl;
    deque<int>d1;
    d1.push_back(10);
    d1.push_back(20);
    d1.push_front(100);
    d1.push_front(200);
    printDeque(d1);
    //删除第一个元素  很简单 注释掉了
    //d1.erase(d1.begin());
    //printDeque(d1);
    //删除第二个元素
    deque<int>::iterator it = d1.begin();
    it++;
    d1.erase(it);
    //200 10 20
    printDeque(d1);
    //按区间方式删除
    d1.erase(d1.begin(), d1.end());
    //等价于
    //d1.clear();
    printDeque(d1);
}

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

输出结果：

test01测试输出:
200 100 10 20
200 100 10
100 10
test02测试输出:
200 100 10 20
90 200 100 10 20
80 80 90 200 100 10 20
1 2 3 80 80 90 200 100 10 20
test03测试输出:
200 100 10 20
200 10 20

请按任意键继续. . .

总结：插入和删除提供的位置是迭代器

2.6deque数据存取

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

函数原型：

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

#include <iostream>
using namespace std;
#include<deque>
//deque容器数据存取
//at(int idx); //返回索引idx所指的数据
//operator[];  //返回索引idx所指的数据
//front();     //返回容器中第一个数据元素
//back();      //返回容器中最后一个数据元素
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();
    system("pause");
    return 0;
}

输出结果：

300 200 100 10 20 30
300 200 100 10 20 30
第一个元素为：300
最后一个元素为：30
请按任意键继续. . .

2.7deque排序

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

算法：

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

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

#include <iostream>
using namespace std;
#include<deque>
#include<algorithm>//标准算法头文件
//deque排序
//sort(iterator beg, iterator end);//对beg和end区间内元素进行排序

void printDeque(const deque<int>& d)
{
    for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}
    
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
    printDeque(d);
    //排序 默认排序规则：从小到大 升序
    //对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
    //vector容器也可以利用sort进行排序
    sort(d.begin(), d.end());
    cout << "排序后：" << endl;
    printDeque(d);
}

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

输出结果：

300 200 100 10 20 30
排序后：
10 20 30 100 200 300
请按任意键继续. . .

3、案例---评委打分

案例描述：有5名选手:选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。

实现步骤：
1、创建五名选手，放到vector中
2、遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中 3、sort算法对deque容器中分数排序，去除最高和最低分
4、deque容器遍历一遍，累加总分
5、获取平均分

#include <iostream>
using namespace std;
#include<deque>
#include<vector>
#include<algorithm>//标准算法头文件
#include<string>
#include<ctime>
/*
有5名选手:选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分
*/
//选手类
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 avg = sum / d.size();
        //将平均分 赋值给选手身上
        it->m_Score = avg;
    }
}

void showScore(vector<Person>& v)
{
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名：" << (*it).m_Name << " 平均分：" << (*it).m_Score << endl;
    }
}

int main()
{
    //创建随机数种子
    //这样每次产生的得分就会不同
    //srand((unsigned int)time(NULL));

    //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 << endl;
    }*/

    //2、给5名选手打分
    setScore(v);
    //3、显示最后得分
    showScore(v);
    system("pause");
    return 0;
}

输出结果：

姓名：选手A 平均分：78
姓名：选手B 平均分：82
姓名：选手C 平均分：74
姓名：选手D 平均分：80
姓名：选手E 平均分：77
请按任意键继续. . .

正直和知府

关注

47
点赞
踩
41

收藏

觉得还不错? 一键收藏
0
评论
C++提高笔记（三）---STL容器（vector、deque）

C++提高---STL容器（vector、deque）
复制链接

扫一扫

专栏目录

C++提高笔记（三）---STL容器（vector、deque）

1、vector容器

1.1vector基本概念

1.2vector构造函数

1.3vector赋值操作

1.4vector容量和大小

1.5vector插入和删除

1.6vector数据存取

1.7vector互换容器

1.8vector预留空间

2、deque容器

2.1deque容器基本概念

2.2deque构造函数

2.3deque赋值操作

2.4deque大小操作

2.5deque插入和删除

2.6deque数据存取

2.7deque排序

3、案例---评委打分

“相关推荐”对你有帮助么？