C++笔记打卡第18天（vector、deque）

最新推荐文章于 2024-07-12 10:45:15 发布
最新推荐文章于 2024-07-12 10:45:15 发布
阅读量464 收藏 2
点赞数 13
文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57139639/article/details/138000704
版权

1.vector容器

  • vector数据结构和数组非常相似，也称为单端数组
  • 不同之处在于数组是静态空间，而vector可以动态扩展
  • 动态扩展：并不是在原空间之后需接新空间，而是找更大的内存空间，然后将原数据拷贝到新空间，释放原空间
  • vector容器的迭代器是支持随机访问的迭代器

打印vector容器：

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

vector的构造：

#include<vector>
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());

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

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

vector的赋值：

void test01()
{
    vector<int> v1;
    for(int i=0; i<10; i++)
    {
        v1.push_back(i);
    }
    
    // =号赋值
    vector<int> v2;
    v2 = v1;

    // assign
    vector<int> v3;
    v3.assign(v1.begin(), v1.end());

    // n个elem赋值
    vector<int> v4;
    v4.assign(10, 100);
}

vector的容量和大小：

v1.empty()、v1.capacity()、v1.size()、v1.resize()

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);  // v1.resize(15,100); 用100来来填充
    printVector(v1);  // 如果重新指定的长度比原来长，默认用0来填充

    v1.resize(5); // 如果重新指定的长度比原来短，超出部分会删除掉
}

vector的插入和删除：

void test01()
{
    vector<int> v1;
    for(int i=0; i<10; i++)
    {
        v1.push_back(i); // 尾插法
    }
    printVector(v1);

    // 插入
    v1.insert(v1.begin(), 100);  // 第一个数据是迭代器
    v1.insert(v1.begin(), 2, 1000);  // 头插2个1000

    // 删除,参数也是迭代器
    v1.pop_back(); // 尾删法
    v1.erase(v1.begin());
    v1.erase(v1.begin(), v1.end()); // 等效于清空
    
    // 清空
    v1.clear();
}

vector的数据读写：

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;
}

vector的互换容器（实现两个容器内的元素互换）：

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);
}

// 实际用途：巧用swap可以收缩内存空间
void test02()
{
    vector<int> v;
    for(int i=0; i<10000; i++)
    {
        v.push_back(i); 
    }
    cout << "v的容量:" << v.capacity() << endl;  // 16384
    cout << "v的大小:" << v.size() << endl;  // 10000

    v.resize(3);
    cout << "v的容量:" << v.capacity() << endl;  // 16384
    cout << "v的大小:" << v.size() << endl;  // 3

    // 巧用swap收缩内存
    vector<int>(v).swap(v);
    cout << "v的容量:" << v.capacity() << endl;  // 3
    cout << "v的大小:" << v.size() << endl;  // 3
}

vector预留空间

void test01()
{
    vector<int> v;

    // 提前利用reserve提前预留100000个空间
    v.reserve(100000);

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

2.deque容器

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

deque与vector的区别：

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

打印deque容器：

void printDeque(const deque<int> &d1)  // 只读迭代器
{
    for(deque<int>::const_iterator it = d1.begin(); it != d1.end(); it++)
    {
        // *it = 100; 错误，加入const之后此时容器中的数据不能修改
        cout << *it << " ";
    }
    cout << endl;
}

deque的构造函数

#include<deque>

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());

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

    deque<int> d4(d3);
}

deque赋值操作

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

    // =号赋值
    deque<int> d2;
    d2 = d1;

    deque<int> d3;
    d3.assign(d1.begin(), d1.end());

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

    deque<int> d5(d1);   
}

deque大小操作

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

    if(d1.empty())
    {
        cout << "deque为空" << endl;
    }
    else
    {
        cout << "deque不为空" << endl;
        cout << "deque的大小为:" << d1.size() << endl;
        // deque没有容量的概念
    }
    // 重新指定大小
    d1.resize(15);  // d1.resize(15, 100);
    d1.resize(5);
}

deque插入和删除

// 两端操作
void test01()
{
    deque<int> d1;
    // 尾插
    d1.push_back(10);
    d1.push_back(20);
    // 头插
    d1.push_front(100);
    d1.push_front(200);
    printDeque(d1);  // 200 100 10 20

    // 尾删
    d1.pop_back();
    // 头删
    d1.pop_front();
    printDeque(d1);  // 100 10  
}

// 对指定位置进行插入
void test02()
{
    deque<int> d;
    d.push_back(10);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);

    // insert插入
    d.insert(d.begin(), 1000);
    d.insert(d.begin(), 2, 10000); // 插入2个10000
    
    // 按照区间进行插入
    deque<int> d2;
    d2.push_back(1);
    d2.push_back(2);
    d2.push_back(3);

    d.insert(d.begin(), d2.begin(), d2.end());
}

// 对指定位置进行删除
void test03()
{
    deque<int> d;
    d.push_back(10);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);
    
    deque<int>::iterator it = d.begin();  // 先设置出迭代器
    it++;
    d.erase(it);  // 删除了第二个数据
    d.erase(d.begin(), d.end());
    d.clear();
}

deque数据存取

void test01()
{
    deque<int> d;
    // 尾插
    d.push_back(10);
    d.push_back(20);
    // 头插
    d.push_front(100);
    d.push_front(200);
    
    // 通过[]访问元素
    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;
}

deque排序

#include<deque>
#include<algorithm>

void test01()
{
    deque<int> d;
    d.push_back(10);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);

    // 默认升序排列
    // 对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
    // vector容器也可以利用sort进行排序
    sort(d.begin(), d.end());
    printDeque(d);
}

3.案例-评委打分

有5名选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除最低分，取平均分。

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

class Person
{
public:
    Person(string name, int score)
    {
        this->m_name = name;
        this->m_score = score;
    }
    string m_name;
    int m_score;  // 平均分
};

void printVector(vector<Person> &v)
{
    for(vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名：" << (*it).m_name << " 分数：" << (*it).m_score << endl;
    }
}

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);
        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; // 0~40 + 60
            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 = sum + *dit;
        }
        int avg = sum / d.size();
        it->m_score = avg;
    }
}

void test01()
{
    vector<Person> v;
    creatPerson(v);
    // for(vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    // {
        // cout << "姓名：" << it->m_name << " 分数：" << it->m_score << endl;
    // }
    SetScore(v);
    printVector(v);

}

int main()
{
    // 随机数种子
    srand((unsigned int)time(NULL));
    test01();
    system("pause");
    return 0;
}

Cycal1020
关注
  • 13
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++ STL案例(vector+deque容器)
03-14
案例-评委打分 ...遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中 sort算法对deque容器中分数排序，去除最高和最低分 deque容器遍历一遍，累加总分 获取平均分
C++ STL入门教程(3) deque双向队列使用方法
08-29
C++ STL deque双向队列使用方法 在 C++ STL 中，deque（Double Ended Queues，双向队列）是一种非常有用的容器，它允许在容器头部快速插入和删除（就像在尾部一样）。本文将详细介绍 deque 的使用方法，以便读者更...
C++Vector和deque容器
八天一吨水的博客
11-23 674
动态扩展并不是在原有的空间进行扩展，而是新建一个比原来更大的空间，空间的大小由vector内部的算法确定。如果vector要存放的数据比较多，可以直接预留足够的空间，不用一次次地动态扩展，影响性能。与数组类似，但是数组是固定长度，vector是长度可变的，可以动态扩展的。作用：提前预留空间，减少动态扩展容量时的扩展次数。vector是STL中最常用的一种数据结构。deque是一个双端数组，可对头端进行插入。reserve只预留空间不初始化数据。利用算法实现deque内部数据的排序。
deque与vector的主要区别
xiaoxianerqq的专栏
12-25 904
转自 ： http://www.cnblogs.com/zhuyf87/archive/2012/12/09/2809896.html              http://blog.csdn.net/jxxfqyy/article/details/6629935 deque与vector非常相似。它也采用动态数组管理元素，提供随机存取，有着和vector几乎一样的接
C++提高笔记（三）---STL容器（vector、deque）
m0_46359434的博客
03-13 2136
C++提高---STL容器（vector、deque）
C++笔记打卡第17天（STL、容器）
weixin_57139639的博客
04-19 1132
C++笔记打卡第17天（STL、容器）
C++笔记打卡第24天（演讲比赛流程管理系统）
weixin_57139639的博客
04-28 969
C++笔记打卡第24天（演讲比赛流程管理系统）
【c/c++算法刷题笔记】—— LeetCode打卡01
Paul 的笔记库
03-03 547
【前言】洛谷闯关暂时告一段落，之后会把笔记放上来。这几天参加一个《剑指offer》打卡活动，用的牛客网oj。剑指offer共67题，一天6题，打卡十一天。如果有想要一起小伙伴在下方留言吧~ 数组中重复的数字 题目描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输...
《Effective Modern C++》学习笔记之条款四十二：考虑置入而非插入
王木木
03-20 6715
如果你有个容器，持有一些，比如说，std::string型别的对象，那么似乎合乎逻辑的做法是用某个插入函数insertion function来向其中添加新元素，比如insert，push_front和push_back，又或者对于std::forward_list而言的insert_after，而传递给函数的元素型别将是std::string。毕竟，那正是容器持有物的型别。 1. 分析为什么push_back效率不高 说合乎逻辑倒也确实合乎逻辑，但却不一定合乎事实。考虑这段代码： std::vect
leetcode笔记
愚人国度的king的博客
09-16 644
输入处理 详细可以看这个网址：https://ac.nowcoder.com/acm/contest/5652 输入如下： a,c,bb f,dddd nowcoder 输出如下： a,bb,c dddd,f nowcoder #include <bits/stdc++.h> #include <sstream> #include <string> #include <stdio.h> using namespace std; int main() {
猿创征文｜我的C C++技术成长之路_c++程序员成长之路
2401_84141419的博客
05-01 43
我觉得编程和写作不仅是对我能力与技术的提升，而且对我的生活也造成了很大的影响，在写作和打代码之余，我也会去户外做做运动锻炼，加强体魄，而且时刻关注一些互联网数字大会之类的活动，有空的话也会去参加一下。这是我在家附近的公园的晨跑照，不得不说，早上跑步真的蛮好的，空气也好，没有人，大家如果有兴趣也可以多去户外晨跑锻炼哦🏃。(img-GFqhVTgx-1714544511778)]不仅是对于实验室中的题目有过痛哭的回忆，自己在其他刷题网站上也是坎坷重重。特别是这一段逻辑，思考了蛮久，具体代码就不展示了😄。
6-3 Deque_pta_C++_6-3deque_
10-02
标题中的“6-3 Deque”指的是一个编程练习或课程，可能来自Programming Tournament and Assessment (PTA) 平台，该平台提供各种编程挑战来帮助用户提升技能。在这个练习中，重点是数据结构（DS）的双端队列（Deque）...
c++ vector模拟实现代码
12-20
C++中的`vector`是一个非常重要的STL容器，它提供了类似于动态数组的功能，允许在运行时改变其大小。下面我们将详细讨论`vector`的主要特点、内部实现原理以及模拟实现的代码解析。 1. **vector的基本特性** - `...
深入分析C++中deque的使用
09-05
在C++标准库中，`deque`（双端队列）是一种非常重要的容器，它提供了类似于数组的功能，但同时也允许高效地在两端进行插入和删除操作。与`vector`相比，`deque`在某些场景下提供了更好的性能。下面我们将详细讨论`...
函数模板与类模板
最新发布
程序员_小兵
07-12 1549
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
C++ 多态
wxk2227814847的博客
07-10 788
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 375
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ vector deque list
09-02
C++中的`vector`、`deque`和`list`都是STL（Standard Template Library）中的容器类，用于存储和操作数据。 `vector`是一个动态数组，可以在数组末尾高效地添加或删除元素，也可以通过索引直接访问元素。由于连续的内存分配，`vector`对于随机访问非常高效，但插入和删除操作可能涉及大量元素的移动。 `deque`（双端队列）类似于`vector`，但它允许在数组的前后进行高效地添加或删除元素。与`vector`相比，`deque`在两端的插入和删除操作更加高效，但随机访问的性能略低。 `list`是一个双向链表，在任意位置插入或删除元素的开销都是固定的。由于没有连续内存分配，`list`的随机访问相对较慢，但在插入和删除操作上非常高效。 根据实际需求，选择适合的容器类进行数据存储和操作。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值