【C++ STL之map，set，pair详解】
目录
- 一.map映射
-
- 1.简介
- 2.包含头文件及其初始化
- 3.基本操作
- 4.用迭代器正反遍历
- 5.添加元素的四种方式
- 6.元素的访问
- 7.对比unordered_map，multimap
- 二.set集合
-
- 1.简介
- 2.包含头文件及其初始化
- 3.基本操作
- 4.元素的访问
- 5.set，multiset，unordered_set，unordered_multiset 比较
- 三.pair二元组
-
- 1.简介
- 2.包含头文件及其初始化
- 3.访问与修改
一.map映射
1.简介
在C++的STL（Standard Template Library）中，map是一个非常有用的关联容器。它提供了一种键-值对的数据结构，其中的元素按照键的顺序进行排序，并且每个键是唯一的。本文将详细介绍C++ STL中map的使用方法和一些常见操作。
2.包含头文件及其初始化
（1）头文件
#include
（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 （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 （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元素。