map & set
- 一、关联式容器
- 二、键值对
- 三、树形结构的关联式容器
- 1. set
- （1）set 的介绍
- （2）set 的使用
- 2. multiset
- 3. map
- （1）map 的介绍
- （2）map 的使用
- 4. multimap
- 四、map 和 set 的练习
- 1. 前K个高频单词
- 2. 两个数组的交集
一、关联式容器
我们在前面已经接触过 STL 中的部分容器，比如：vector、list、deque、等，这些容器统称为序列式容器(一级容器)，因为其底层为线性序列的数据结构，里面存储的是元素本身。
那什么是关联式容器？它与序列式容器有什么区别？关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是 <key, value> 结构的键值对，在数据检索时比序列式容器效率更高。
二、键值对
用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量 key 和 value，key 代表键值，value 表示与 key 对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。
SGI-STL中关于键值对的定义：
template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(): first(T1()), second(T2())
{}
pair(const T1& a, const T2& b): first(a), second(b)
{}
};
三、树形结构的关联式容器
根据应用场景的不同，STL 总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：map、set、multimap、multiset；这四种容器的共同点是：使用平衡搜索树(即红黑树) 作为其底层结果，容器中的元素是一个有序的序列。下面一依次介绍每一个容器。
1. set
（1）set 的介绍
首先我们可以看一下 set 的文档介绍：set 文档介绍.
简单概括：
-
set 是按照一定次序存储元素的容器
-
在 set 中，元素的 value 也标识它(value就是 key，类型为 T)，并且每个 value 必须是唯一的。
set 中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。 -
set 在底层是用二叉搜索树(红黑树)实现的。
注意：
- 与 map/multimap 不同，map/multimap 中存储的是真正的键值对 <key, value>，set 中只放 value，但在底层实际存放的是由 <value, value> 构成的键值对。
- set 中插入元素时，只需要插入 value 即可，不需要构造键值对。
- set 中的元素不可以重复 (因此可以使用set进行去重) ；
- 使用 set 的迭代器遍历 set 中的元素，可以得到有序序列；
- set 中的元素默认按照小于来比较；
- set 中查找某个元素，时间复杂度为：O(logN).
（2）set 的使用
在使用之前我们先看一下 set 的模板参数列表：
其中：
- T: set 中存放元素的类型，实际在底层存储 <value, value> 的键值对。
- Compare：仿函数，set 中元素默认按照小于来比较
- Alloc：set 中元素空间的管理方式，使用STL提供的空间配置器管理
- insert
下面我们简单插入几个元素并打印出来：
void test1()
{
set<int> s;
s.insert(2);
s.insert(6);
s.insert(1);
s.insert(4);
s.insert(9);
s.insert(9);
s.insert(9);
s.insert(0);
for (auto& e : s)
{
cout << e << " ";
}
cout << endl;
}
由于 set 底层有迭代器，所以可以使用范围 for. 运行结果如下：
我们看到 set 打印出来是有序的并且去重了；在这里我们可以看一下 insert 的返回值：
如上图，当我们插入的是一个值的时候，它的返回值是一个 pair 类型的键值对，所以我们可以简单用一个 pair 类型的变量接收，观察它对应的数据，如下：
void test1()
{
set<int> s;
s.insert(2);
s.insert(6);
s.insert(1);
s.insert(4);
s.insert(9);
s.insert(0);
pair<set<int>::iterator, bool> it1 = s.insert(9);
cout << *(it1.first) << " ";
cout << it1.second<< endl;
pair<set<int>::iterator, bool> it2 = s.insert(10);
cout << *(it2.first) << " ";
cout << it2.second << endl;
}
如上代码，我们在已经有 9 的 s 中再次插入 9，我们观察它的返回值中的 first 和 second；然后我们插入 s 中没有的 10，继续观察；结果如下：
如上图，我们看到插入已有元素后，因为返回的 first 是个迭代器，所以需要解引用才能得到里面的值，里面的值给我们返回了已经存在的 9；而 second 返回了 0 即 false，代表插入失败。
插入没有的元素的时候 first 返回的是新插入的值所在节点的迭代器；second 则是 1，即 true，代表插入成功。
- erase
删除和我们往常用的差不多，直接删除需要删除的元素即可；注意删除成功返回 1；删除失败返回 0；
也可以直接给迭代器的位置直接删除，没有返回值。
如下代码：
void test1()
{
set<int> s;
s.insert(2);
s.insert(6);
s.insert(1);
s.insert(4);
s.insert(9);
s.insert(0);
// 打印删除前
for (auto& e : s)
{
cout << e << " ";
}
cout << endl;
// 打印删除结果
cout << s.erase(1) << endl;
cout << s.erase(20) << endl;
// 打印删除后
for (auto& e : s)
{
cout << e << " ";
}
cout << endl;
}
结果如下：
- find
如上图我们看到，find 的返回值是 iterator，那么返回的是哪个位置的迭代器呢？我们继续看它的返回值：
如上，如果找到这个元素，则返回这个元素所以在位置的迭代器；否则返回 end() 位置。可以如下使用：
void test2()
{
set<int> s;
s.insert(2);
s.insert(6);
s.insert(1);
s.insert(4);
s.insert(9);
s.insert(0);
set<int>::iterator it = s.find(6);
if (it != s.end())
{
s.erase(it);
}
for (auto& e : s)
{
cout << e << " ";
}
cout << endl;
}
- count
count 返回值就是统计这个元素出现多少次，但是 set 的一个特性是去重，所以返回值只有 1 和 0；所以一般用来判断在不在；如下：
void test2()
{
set<int> s;
s.insert(2);
s.insert(6);
s.insert(1);
s.insert(4);
s.insert(9);
s.insert(0);
if (s.count(6))
{
cout << "6在" << endl;
}
else
{
cout << "6不在" << endl;
}
if (s.count(10))
{
cout << "10在" << endl;
}
else
{
cout << "10不在" << endl;
}
}
- lower_bound 和 upper_bound
- lower_bound 是返回一个 >= val 值位置的 iterator ；
- upper_bound 是返回一个 > val 值位置的 iterator ；
使用如下：
void test3()
{
set<int>::iterator itlow, itup;
set<int> s;
// 插入 10 20 30 40 50 60 70 80 90
for (int i = 1; i < 10; i++)
s.insert(i * 10);
itlow = s.lower_bound(25);
itup = s.upper_bound(70);
s.erase(itlow, itup); // 删除区间 [30, 40, 50, 60, 70]
for (auto& e : s)
{
cout << e << " ";
}
cout << endl;
}
结果如下：
- equal_range
如上图介绍，equal_range 是返回一个 pair 类型，是一个范围的边界，该范围包括 s 中与 val 等价的所有元素。使用如下：
void test4()
{
set<int> s;
// 插入 10 20 30 40 50 60 70 80 90
for (int i = 1; i < 10; i++)
s.insert(i * 10);
auto ret = s.equal_range(30);
cout << *ret.first << endl; // >= val
cout << *ret.second << endl; // > val
}
结果如下：
2. multiset
multiset 文档介绍
multiset 是按照特定顺序存储元素的容器，其中元素是可以重复的；它与 set 的区别就是 multiset 可以插入重复的元素。
- multiset 的使用
multiset 的许多接口都与 set 重复，所以它们的用法大体一致；
在这就介绍一下 find，如果有多个 val ，find 返回中序的第一个 val.
如下段代码：
void test5()
{
multiset<int> ms;
ms.insert(2);
ms.insert(2);
ms.insert(1);
ms.insert(4);
ms.insert(2);
ms.insert(2);
ms.insert(0);
for (auto& e : ms)
cout << e << " ";
cout << endl;
multiset<int>::iterator it = ms.find(2);
while (it != ms.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
结果如下，说明 find 是返回中序的第一个2：
3. map
（1）map 的介绍
我们先看一下 map 的文档介绍：map 文档介绍 .
简单概括：
- map 是关联容器，它按照特定的次序(按照 key 来比较)存储由键值 key 和值 value 组合而成的元素。
- 在 map 中，键值 key 通常用于排序和唯一地标识元素，而值value 中存储与此键值 key 关联的内容。键值 key 和值 value 的类型可能不同，并且在 map 的内部，key 与 value 通过成员类型 value_type 绑定在一起，为其取别名称为 pair：
typedef pair<const key, T> value_type; 如下图，是文档内容的截取：
- 在内部，map 中的元素总是按照键值 key 进行比较排序的。
- map 中通过键值访问单个元素的速度通常比 unordered_map 容器慢，但 map 允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
- map 支持下标访问符，即在
[]中放入 key，就可以找到与 key 对应的 value。 - map 通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。
（2）map 的使用
- insert
因为 map 插入的是一对键值对，所以需要以 pair 的形式插入；我们先看一下 pair 的文档介绍：pair 文档介绍
其中它的构造函数如下：
但是我们习惯用以下这个接口初始化一个键值对对象：make_pair，如下：
所以我们插入的时候可以以如下两种方式插入：
void test6()
{
map<string, string> dict;
dict.insert(pair<string, string>("insert", "插入"));
dict.insert(make_pair("string", "字符串"));
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
cout << (*it).first << ":" << (*it).second << endl;
//cout << it->first << ":" << it->second << endl;
++it;
}
}
因为 iterator 迭代器封装的是一个个节点，所以解引用得到的是一个 pair 类型的键值对，所以解引用后使用 . 指定访问 first 还是 second；而 -> 我们在 list 部分讲过，当节点中存的类型是自定义类型的时候，我们使用 -> 就可以方便一点进行指定元素的访问，而 pair 正好就是自定义类型，所以用 -> 访问更方便。
注意，这里的是省略了一个 ->，实际上 it->first 就是 it.operator->()->first；其中 it.operator->() 是取到 pair 的地址，再使用 -> 即可进行指定元素访问。
然后其它接口的使用和 set 的用法差不多，只是 map 的类型变成了 pair 而已；所以其它接口不再进行介绍，下面开始介绍 map 中的最重要的接口：operator[].
- operator[]
如上图和下图，operator[] 的返回值是 pair 的第二个模板参数：
我们先看一下 operator[] 的使用，如下段代码：
void test7()
{
string array[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> mapCount;
for (auto& str : array)
mapCount[str]++;
for (auto& kv : mapCount)
cout << kv.first << ":" << kv.second << endl;
}
结果如下：
实际上，调用 operator[] 就是在调用：(*((this->insert(make_pair(k,mapped_type()))).first)).second
如下图是原文档的解释：
分析如下：
其中 mapped_type 是 map 模板中的第二个模板参数类型，mapped_type() 则是默认构造的匿名对象，所以我们传 int 类型的时候，如果 key 在 map 中没有，则初始化为 0；如果有则返回 key 对应的 value；所以当我们 ++ 的时候，就可以统计次数，其实 ++ 就是作用到 pair 的 value 上。
总结：
- map 中的的元素是键值对
- map 中的 key 是唯一的，并且不能修改
- 默认按照小于的方式对 key 进行比较
- map 中的元素如果用迭代器去遍历，可以得到一个有序的序列
- map 的底层为平衡搜索树(红黑树)，查找效率比较高 O(logN).
- 支持
[]操作符，operator[]中实际进行插入查找；
4. multimap
我们可以看一下文档介绍：multimap 文档介绍
multimap 和 map 的唯一不同就是：map 中的 key 是唯一的，而multimap 中 key 是可以重复的。
multimap 的使用可以参考 map，功能都是类似的，这里不再作介绍；
注意：
- multimap 中的 key 是可以重复的。
- multimap 中的元素默认将 key 按照小于来比较
- multimap 中没有重载 operator[] 操作，因为 key 是可以重复的，如果此时有多个 key，就不知道返回哪个 key 对应的 value了；而且当有 key 的时候，再来一个 key，就不知道是查找还是修改了。
- 使用时与map包含的头文件相同：
四、map 和 set 的练习
1. 前K个高频单词
题目链接 -> Leetcode -692.前K个高频单词
Leetcode -692.前K个高频单词
题目：给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
示例 1：
输入 : words = [“i”, “love”, “leetcode”, “i”, “love”, “coding”], k = 2
输出 : [“i”, “love”]
解析 : “i” 和 “love” 为出现次数最多的两个单词，均为2次。
注意，按字母顺序 “i” 在 “love” 之前。
示例 2：
输入 : [“the”, “day”, “is”, “sunny”, “the”, “the”, “the”, “sunny”, “is”, “is”] , k = 4
输出 : [“the”, “is”, “sunny”, “day”]
解析 : “the”, “is”, “sunny” 和 “day” 是出现次数最多的四个单词，
出现次数依次为 4, 3, 2 和 1 次。
注意：
1 <= words.length <= 500
1 <= words[i] <= 10
words[i] 由小写英文字母组成。
k 的取值范围是[1, 不同 words[i] 的数量]
思路是先将 words 中的内容放入 map 中统计次数，再放入优先级队列中按照 cmp 方式进行比较确认优先级；其中 cmp 方法是次数多的优先，如果次数多的就按照字典顺序比较；代码如下：
class Solution
{
public:
// 仿函数，按照 pair 中的 second 比较，降序；如果 second 相等，按照字典顺序排序
class cmp
{
public:
bool operator()(const pair<string, int>& p1, const pair<string, int>& p2)
{
return p1.second < p2.second || (p1.second == p2.second && p1.first > p2.first);
}
};
vector<string> topKFrequent(vector<string>& words, int k)
{
priority_queue<pair<string, int>, vector<pair<string, int>>, cmp> pq;
map<string, int> mp;
// 先放入 map 中统计次数
for (auto& str : words)
mp[str]++;
// 再放入优先级队列中
for (auto& str : mp)
pq.push(str);
// 取优先级队列的前 k 个
vector<string> ret;
while (k--)
{
ret.push_back(pq.top().first);
pq.pop();
}
return ret;
}
};
2. 两个数组的交集
题目链接 -> Leetcode -349.两个数组的交集
Leetcode -349.两个数组的交集
题目：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1：
输入：nums1 = [1, 2, 2, 1], nums2 = [2, 2]
输出：[2]
示例 2：
输入：nums1 = [4, 9, 5], nums2 = [9, 4, 9, 8, 4]
输出：[9, 4]
解释：[4, 9] 也是可通过的
提示：
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
思路是将两个数组分别放入 set 中，然后使用双指针找交集； 具体思路如下代码：
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
{
// 将 nums1 和 nums2 分别放入 set 中
set<int> s1(nums1.begin(), nums1.end());
set<int> s2(nums2.begin(), nums2.end());
// 使用双指针的思路
// 两个值相等则是交集，同时++；
// 两个值不相等则小的那个++；
// 直到其中一个结束
vector<int> ret;
set<int>::iterator it1 = s1.begin(), it2 = s2.begin();
while (it1 != s1.end() && it2 != s2.end())
{
if (*it1 == *it2)
{
ret.push_back(*it1);
++it1, ++it2;
}
else if (*it1 < *it2)
{
++it1;
}
else
{
++it2;
}
}
return ret;
}
};
![[移动通讯]【Carrier Aggregation-13】【Carrier Aggregation】](https://img-blog.csdnimg.cn/aa81d55d3f7e4e5eb946ce6203561378.png)
