【C++ STL之map，set，pair详解】

一.map映射

1.简介

在C++的STL（Standard Template Library）中，map是一个非常有用的关联容器。它提供了一种键-值对的数据结构，其中的元素按照键的顺序进行排序，并且每个键是唯一的。本文将详细介绍C++ STL中map的使用方法和一些常见操作。

2.包含头文件及其初始化

（1）头文件

#include <map>

（2）初始化方法
可以使用以下方式声明和初始化一个map对象：

map<KeyType, ValueType> myMap; // 声明一个空的map
map<string,string> mp;
map<string,int> mp;
map<int,node> mp;//node是结构体类型

也可以使用已有的键值对初始化map对象

std::map<KeyType, ValueType> myMap = {
    {key1, value1},
    {key2, value2},
    {key3, value3}
};

3.基本操作

代码	含义
mp.find(key)	返回键为key的映射的迭代器 注意：用find函数来定位数据出现位置，它返回一个迭代器。当数据存在时，返回数据所在位置的迭代器，数据不存在时，返回mp.end()
mp.erase(it)	删除迭代器对应的键和值
mp.erase(key)	根据映射的键删除键和值
mp.erase(first,last)	删除左闭右开区间迭代器对应的键和值
mp.size()	返回映射的对数
mp.clear()	清空map中的所有元素
mp.insert()	插入元素，插入时要构造键值对
mp.empty()	如果map为空，返回true，否则返回false
mp.begin()	返回指向map第一个元素的迭代器
mp.end()	返回指向map尾部的迭代器（最后一个元素的下一个地址）
mp.rbegin()	返回指向map最后一个元素的反向迭代器
mp.rend()	返回指向map第一个元素前面(上一个）的反向迭代器（地址）
mp.count(key)	查看元素是否存在，存在返回1，不存在返回0
mp.lower_bound()	返回一个迭代器，指向键值>= key的第一个元素（只比较键）
mp.upper_bound()	返回一个迭代器，指向键值> key的第一个元素（只比较键）

接下来将给出相对应代码来帮助理解
（1）使用insert()函数添加单个键值对：

myMap.insert(std::make_pair(key, value));

（2）使用下标运算符[ ]添加或更新键值对：

myMap[key] = value;

（3）使用erase()函数删除指定键的元素：

myMap.erase(key);

（4）使用find()函数查找指定键的元素，返回指向该元素的迭代器：

auto it = myMap.find(key);
if (it != myMap.end()) {
    // 找到了该键对应的元素
    ValueType value = it->second;
}

（5）使用lower_bound()函数查找大于等于指定键的第一个元素的迭代器：

auto it = myMap.lower_bound(key);
if (it != myMap.end()) {
    // 找到了大于等于指定键的第一个元素
    KeyType foundKey = it->first;
    ValueType foundValue = it->second;
}

（6）使用upper_bound()函数查找大于指定键的第一个元素的迭代器：

auto it = myMap.upper_bound(key);
if (it != myMap.end()) {
    // 找到了大于指定键的第一个元素
    KeyType foundKey = it->first;
    ValueType foundValue = it->second;
}

4.用迭代器正反遍历

（正向遍历）

map<int,int> mp;
mp[1] = 2;
mp[2] = 3;
mp[3] = 4;
auto it = mp.begin();
while(it != mp.end())
{
	cout << it->first << " " << it->second << "\n";
	it ++;
}

（反向遍历）

map<int,int> mp;
mp[1] = 2;
mp[2] = 3;
mp[3] = 4;
auto it = mp.rbegin();
while(it != mp.rend())
{
	cout << it->first << " " << it->second << "\n";
	it ++;
}

5.添加元素的四种方式

//先声明
map<string,string> mp;
mp["学习"] = "看书";//第一种
mp["玩耍"] = "打游戏";
mp.insert(make_pair("vegetable","蔬菜"));//第二种
mp.insert(pair<string,string>("fruit","水果"));//第三种
mp.insert({"hahaha","wawawa"});//第四种

6.元素的访问

（1）迭代器访问

int main() {
    std::map<int, std::string> myMap = {
        {1, "Alice"},
        {2, "Bob"},
        {3, "Charlie"}
    };
    // 使用迭代器进行遍历和访问
    for (auto it = myMap.begin(); it != myMap.end(); ++it) {
        int key = it->first;            // 访问键
        string value = it->second;     // 访问值
        cout << key << ": " << value << std::endl;
    }
    return 0;
}

（2）智能指针访问

for(auto i : mp)
cout << i.first << " " << i.second << endl;//键，值

（3）单个访问

map<char,int>::iterator it = mp.find('a');
cout << it -> first << " " <<  it->second << "\n";

（4）c++17特性才具有

for(auto [x, y] : mp)
	cout << x << " " << y << "\n";
//x,y对应键和值

7.对比unordered_map，multimap

1.map：map是一个有序的关联容器，其中的元素按照键的顺序进行排序。每个键是唯一的，不允许重复。map使用红黑树实现，插入和查找操作的时间复杂度为O(log n)。

2.unordered_map：unordered_map是一个无序的关联容器，其中的元素没有特定的顺序。每个键是唯一的，不允许重复。unordered_map使用哈希表实现，插入和查找操作的平均时间复杂度为O(1)，最坏情况下为O(n)。（也是用哈希表实现）

3.multimap：multimap是一个有序的关联容器，其中的元素按照键的顺序进行排序。允许键重复，即可以有相同的键。multimap使用红黑树实现，插入和查找操作的时间复杂度为O(log n)。

4.unordered_multimap：unordered_multimap是一个无序的关联容器，其中的元素没有特定的顺序。允许键重复，即可以有相同的键。unordered_multimap使用哈希表实现，插入和查找操作的平均时间复杂度为O(1)，最坏情况下为O(n)。
对比优劣：

（1）map和unordered_map都提供了快速的查找操作，但是在插入和删除操作上，unordered_map通常比map更快。

（2）unordered_map的元素没有特定的顺序，适用于不需要保持顺序的场景。而map的元素是有序的，适用于需要按照键的顺序进行访问的场景。

（3）multimap和unordered_multimap允许键重复，适用于需要存储相同键的场景。multimap保持元素的有序性，而unordered_multimap没有特定的顺序。

（4）在空间占用上，哈希表实现的容器(unordered_map和unordered_multimap)通常需要更多的内存，而红黑树实现的容器(map和multimap)通常需要较少的内存。

选择使用哪种容器取决于具体的需求。如果需要有序访问或者需要保持元素的有序性，可以选择map或multimap。如果对元素的顺序没有特定要求，但需要快速的插入和查找操作，可以选择unordered_map或unordered_multimap。

二.set集合

1.简介

在C++的STL（Standard Template Library）中，set是一个非常有用的关联容器。它提供了一种有序集合的数据结构，其中的元素按照键的顺序进行排序，并且每个键是唯一的。本文将详细介绍C++ STL中set的使用方法和一些常见操作。

2.包含头文件及其初始化

（1）头文件

#include <set>

（2）初始化

std::set<KeyType> mySet; // 声明一个空的set
std::set<KeyType> mySet = {element1, element2, element3};//也可以使用已有的元素初始化set对象：

3.基本操作

代码	含义
s.begin()	返回set容器的第一个元素的地址（迭代器）
s.end()	返回set容器的最后一个元素的下一个地址（迭代器）
s.rbegin()	返回逆序迭代器，指向容器元素最后一个位置
s.rend()	返回逆序迭代器，指向容器第一个元素前面的位置
s.clear()	删除set容器中的所有的元素,返回unsigned int类型
s.empty()	判断set容器是否为空
s.insert()	插入一个元素
s.size()	返回当前set容器中的元素个数
erase(iterator)	删除定位器iterator指向的值
erase(first,second）	删除定位器first和second之间的值（左闭右开）
erase(key_value)	删除键值key_value的值
s.find(元素)	查找set中的某一元素，有则返回该元素对应的迭代器，无则返回end（）
s.lower_bound(k)	返回大于等于k的第一个元素的迭代器
s.upper_bound(k)	返回大于k的第一个元素的迭代器访问

接下来将给出相对应代码来帮助理解

1.插入元素
mySet.insert(element);
mySet.insert(beginIterator, endIterator);

2.删除元素
mySet.erase(value);
mySet.erase(beginIterator, endIterator);//注意左闭右开

3.查找元素
auto it = mySet.find(value);
if (it != mySet.end()) {
    // 找到了该值对应的元素
}

auto it = mySet.lower_bound(value);
if (it != mySet.end()) {
    // 找到了大于等于指定值的第一个元素
}

auto it = mySet.upper_bound(value);
if (it != mySet.end()) {
    // 找到了大于指定值的第一个元素
}

4.元素的访问

（1）迭代器访问

for(set<int>::iterator it=s.begin();it!=s.end();it++)
	cout<<*it<<" ";

（2）智能指针

for(auto i : s)
	cout<<i<<endl;

（3）访问最后一个元素

//第一种
cout<<*s.rbegin()<<endl;

 //第二种
set<int>::iterator iter = s.end();
iter--;
cout<<(*iter)<<endl; //打印2;

//第三种
cout<<*(--s.end())<<endl;

5.set，multiset，unordered_set，unordered_multiset 比较

1.set：有序的关联容器，每个元素都是唯一的。使用红黑树实现，插入和查找的时间复杂度为O(log n)。元素按照键的顺序进行排序。

2.multiset：有序的关联容器，允许元素重复。使用红黑树实现，插入和查找的时间复杂度为O(log n)。元素按照键的顺序进行排序。

3.unordered_set：无序的关联容器，每个元素都是唯一的。使用哈希表实现，插入和查找的平均时间复杂度为O(1)，最坏情况下为O(n)。元素没有特定的顺序。

4.unordered_multiset：无序的关联容器，允许元素重复。使用哈希表实现，插入和查找的平均时间复杂度为O(1)，最坏情况下为O(n)。元素没有特定的顺序。

总结：
set和multiset是有序的，元素按照键的顺序进行排序，multiset允许元素重复。
unordered_set和unordered_multiset是无序的，元素没有特定的顺序，unordered_multiset允许元素重复。
set和unordered_set的查找和插入操作的时间复杂度较低，适用于需要快速查找和插入的场景。
multiset和unordered_multiset允许元素重复，适用于需要存储相同键的场景。
unordered_set和unordered_multiset在插入和查找操作上通常比set和multiset更快，但它们没有保持元素的有序性。

三.pair二元组

1.简介

在C++的STL（Standard Template Library）中，pair是一个非常有用的模板类。它提供了一种简单的方式来存储一对值，即键值对。pair可以用于各种场景，例如在容器中存储关联的数据，返回多个值等。本文将详细介绍C++ STL中pair的使用方法和一些常见操作。

2.包含头文件及其初始化

（1）头文件

#include <utility>

（2）初始化

pair<Type1, Type2> myPair; // 声明一个空的pair
pair<Type1, Type2> myPair(value1, value2); // 使用给定的值初始化pair
myPair = std::make_pair(value1, value2); // 使用make_pair函数创建pair并赋值

3.访问与修改

//定义结构体数组
pair<int,int>p[20];
for(int i = 0; i < 20; i++)
{
	//和结构体类似，first代表第一个元素，second代表第二个元素
	cout << p[i].first << " " << p[i].second;
}

pair可以作为容器（例如vector、list、map等）的元素使用。这样可以方便地存储和访问关联的数据。
下面是一个使用pair作为容器元素的示例代码：

int main() {
    vector<pair<int, string>> myVector;
    // 添加pair元素
    myVector.push_back(make_pair(1, "Alice"));
    myVector.push_back(make_pair(2, "Bob"));
    myVector.push_back(make_pair(3, "Charlie"));
    // 遍历输出pair元素
    for (const auto& pair : myVector) {
        cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
    }
    return 0;
}

在上述示例代码中，我们创建了一个vector容器myVector，其中的元素是pair类型，包含一个整数和一个字符串。
然后，我们使用push_back()函数向容器中添加了一些pair元素。
最后，我们使用范围遍历来输出容器中的pair元素。