蓝桥杯 第八天 STL:pair和vector

1.pair

1.1.pair定义和结构

在c++中,pair是一个模板类,用于表示一对值的组合,它位于<utility>头文件中.

pair类的定义如下:

template<class T1,class T2>
struct pair {
    T1 first; //第一个值
    T2 second; // 第二个值
    //构造函数
    pair();
    pair(const T1& x, const T2& y);
    
    //比较运算符重载
    bool operator==(const pair& rhs) const;
    bool operator!=(const pair& rhs) const;
}

pair类模板有两个模板参考,T1和T2,分别表示第一个值和第二个值的类型.

pair类有两个成员变量,first和second,分别表示第一个值和第二个值.

pair类还有一些成员函数和特性,例如默认构造函数,带参数的构造函数,比较运算符重载等.

使用pair类,你可以方便地两个值组合在一起,并进行传递,存储和操作.

例如可以将两个整数组合在一起作为函数的返回值,或者将一对值存储在容器中.

#include <bits/stdc++.h>
using namespace std;
int main(){
    //以上代码创建了两pair对象,分别包含不同类型的值.
    pair<int,double> p1(1,3.14);
    pair<char,string> p2('a',"hello");
    //然后,通过访问first 和 second 成员变量,输出了这些值. 
    cout << p1.first << "," << p1.second << '\n';
    cout << p2.first << "," << p2.second << '\n';
    return 0;
}

1.2.pair的嵌套

pair可以进行嵌套,也就是说可以将一个pair对象作为另一个pair对象的成员.

通过嵌套pair,你可以方便地组和多个值,并形成更复杂的数据结构.

例如,你可以创建一个三维坐标系的点,其中第一个维度由一个整数表示,第2,3个维度由一个pair表示.下面是一个示例代码,演示了如何嵌套使用pair:

#include <bits/stdc++.h>

int main(){
    //创建三个pair对象:p1,p2和p3
    //p1是一直简单pair,包含两个整数值
    std::pair<int,int> p1(1,2);
    //p2是一个嵌套的pair,其中第一个值是一个整数,第二个值是一个pair,其中包含两个整数数值
    std::pair<int,std::pair<int,int>> p2(3,std::make_pair(4,5));
    //p3是一个嵌套的pair,其中每个值是一个pair,每个pair包含两个整数值.
    std::pair<std::pair<int,int>,std::pair<int,int>> p3(std::make_pair(6,7), std::make_pair(8,9));
    
    std::cout << p1.first << " , " << p1.second << '\n';
    std::cout << p2.first << " , " << p2.second.first << " , " << p2.second.second << '\n';
    std::cout << p3.first.first << " , " << p3.first.second << " , " << p3.second.first << " , " << p3.second.second << '\n';
    
    return 0;
}

1.3.pair自带排序规则

pair自带的排序规则是按照pair成员进行升序排序.

如果first成员相等,则按照second成员进行升序排序.

这意味着当你使用标准库中的排序算法(如std::sort)对包含pair对象的容器进行排序时,会根据pair对象的first成员进行排序.

//下面时一个示例代码,演示了如何使用pair进行排序:
#include <bits/stdc++.h>
#include <utility>
using namespace std;

int main(){
    vector<pair<int , int>> vec;
    vec.push_back(make_pair(3,2));
    vec.push_back(make_pair(1,4));
    vec.push_back(make_pair(2,1));

    sort(vec.begin(),vec.end());
    
    for(const auto &p:vec){
        cout << p.first<< ", " << p.second << '\n';
    }
    return 0;
}

1.4.代码示例

#include <bits/stdc++.h>
#include <vector>
using namespace std;

//定义一个结构体,表示一个人的信息
struct Person{
    string name;
    int age;
};

int main(){
    //创建一个存储person对象的向量
    vector<Person> people;
    people.push_back({"Alice",25});
    people.push_back({"Bob",30});
    people.push_back({"Charlie",20});

    vector<pair<Person,int>> scores;

    scores.push_back({people[0],90});
    scores.push_back({people[1],85});
    scores.push_back({people[2],95});
    //遍历pair向量,并输出每个人的姓名,年龄,评分
    for(const auto &pair:scores){
        cout << "Name: " << pair.first.name << '\n';
        cout << "Age: " << pair.first.age << '\n';
        cout << "Score: " << pair.second << '\n';
    }
    return 0;
}

2.vector

2.1.vector的定义和特性

在c++中,vector是一个动态(大小)数组容器,可以存储一系列相同类型的元素.

它是标准库<vector>中定义的模板类.

vector的定义和结构非常简单,它由以下几个重要的部分组成:

模板类声明:vector是一个模板类,因此在使用之前需要包含头文件<vector>.声明一个vector对象是通用语法如下:

std::vector<T> vec;

这里的T是要存储在vector中的元素类型(如:int,char,double,vector).

容器大小:vector是一个动态数组,可以根据需要自动调整大小.它会根据元素的数量动态分配内存空间.

元素访问:可以通过索引来访问vector中的元素.索引从0开始,最后一个元素的索引是size()-1,可以使用 [ ] 运算符或at() 函数来访问元素.

元素添加和删除:可以使用push_back()函数在vector的末尾添加元素,使用pop_back()函数删除末尾的元素.还可以使用insert()函数在指定位置插入元素,使用erase()函数删除指定位置的元素.

容器大小管理:可以使用size()函数获取vector中元素的数量,使用empty()函数检查vector是否为空.还可以使用resize()函数调整vector的大小.

迭代器:vector提供了迭代器,可以用于遍历容器中的元素.可以使用begin()函数获取指向第一个元素的迭代器,使用end()函数获取指向最后一个元素之后位置的迭代器.

2.2.vecto的常用函数

push_back():将元素添加到vector的末尾.

pop_back():删除vector末尾的元素.

begin()和end():放回指向vector第一个元素和最后一个元素之后位置的迭代器.

#include <bits/stdc++.h>
using namespace std;

int main(){
    vector<int> vec={10,20,30};
    
    vec.push_back(40);
    for(auto i=vec.begin(); i != vec.end() ; i++) cout << *i << " ";
    cout << '\n';
    
    vec.pop_back();
    for (auto i=vec.begin();i!= vec.end(); i++) cout << *i << " ";

}

2.3.vector排序去重

2.3.1.排序:

要对vector进行排序,可以使用标准库中的std::sort函数.

改函数位于头文件<algorithm>中.

#include<algorithm>
std::vetor<T> vec={...};
std::sort(vec.begin(),vec.end());

 这里的T是vector中元素的类型.

std::sort函数接受两个迭代器参数,表示要排序的范围.

vec.begin()返回指向vector第一个元素的迭代器

vec.end()返回指向最后一个元素之后位置的迭代器.

#include <algorithm>
#include <bits/stdc++.h>
using namespace std;

int main(){
    vector<int> vec = {5,2,8,1,9};
    sort(vec.begin(),vec.end());
    
    for(const auto &num:vec) cout << num << " ";
}

 2.3.2.去重

要去除vector中的重复元素,可以使用std::unique函数.该函数位于头文件<algorithm>中.

#include<algorithm>

std::vector<T> vec = {...}
std::sort(vec.begin(),vec.end());
auto last = std::unique(vec.begin(),vec.end());
vec.erase(last,vec.end());

 首先,需要对vector进行排序,以便相同的元素相邻.然后,std::unique函数将重复的元素移动到vector的末尾,并返回一个指向重复元素的迭代器.最后,可以使用vec.erase函数将重复元素从vecor中删除.

#include <algorithm>
#include <bits/stdc++.h>
#include <vector>
using namespace std;

int main(){
    std::vector<int> vec= {2,1,3,2,4,1,5,4};
    // 1 1 2 2 3 4 4 5 ↓
    sort(vec.begin(),vec.end());
    //获取 1 2 3 4 5 1 2 4 第二个1的位置
    auto last = unique(vec.begin(),vec.end());
    vec.erase(last,vec.end());
    for(const auto &num:vec){
        cout << num << " " ;
    }
    return 0;
}

2.4.代码示例

#include <algorithm>
#include <bits/stdc++.h>
#include <vector>
using namespace std;

int main(){
    pmr::vector<int> numbers;
    numbers.push_back(5);
    numbers.push_back(2);
    numbers.push_back(8);
    numbers.push_back(5);
    numbers.push_back(1);
    numbers.push_back(2);
    numbers.push_back(9);
    numbers.push_back(8);
    //打印向量的元素
    cout << "原始向量中的元素: ";
    for(const auto&number:numbers){
        cout << number << ' ';
    }
    cout << '\n';

    //向量进行排序
    sort(numbers.begin(),numbers.end());
    cout << "排序后的向量: ";
    for(const auto&number:numbers){
        cout << number << ' ';
    }
    cout << '\n';
    
    //去除重复元素
    numbers.erase(unique(numbers.begin(),numbers.end()),numbers.end());
    cout << "去重后的向量: ";
    for(const auto &number:numbers){
        cout << number << " ";
    }
    cout << '\n';

    //向量中插入元素
    numbers.insert(numbers.begin()+2,3);
    cout << "插入元素后的向量: ";
    for(const auto &number:numbers){
        cout << number << " ";
    }
    cout << '\n';

    //删除某个元素的向量
    numbers.erase(numbers.begin()+4);
    cout << "删除元素后的向量: ";
    for(const auto &number:numbers){
        cout << number << " ";
    }
    cout << '\n';

    //检查向量是否为空
    if (numbers.empty()) cout << "向量为空" << '\n';
    else cout << "向量不为空" << '\n';

    //获取向量的大小
    cout << "向量的大小: " << numbers.size() << '\n';

    //清楚向量
    numbers.clear();
    //检查向量是否为空
    if (numbers.empty()) cout << "向量为空" << '\n';
    else cout << "向量不为空" << '\n';

    return 0;
}