1. 序列式容器和关联式容器
前⾯我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，这些容器统称为序列式容器，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间⼀般没有紧密的关联关系，⽐如交换⼀下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的。
关联式容器也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是**⾮线性结构** ，两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。顺序容器中的元素是按关键字来保存和访问的。关联式容器有map/set系列和unordered_map/unordered_set系列。
本章节讲解的map和set底层是红⿊树 ，红⿊树是⼀颗平衡⼆叉搜索树。set是key搜索场景的结构，map是key/value搜索场景的结构。
2. set系列的使用
2.1 set和multiset参考文档
https://legacy.cplusplus.com/reference/set/
2.2 set类的介绍
- set的声明如下，T就是set底层关键字的类型
- set默认要求T⽀持⼩于⽐较，如果不⽀持或者想按⾃⼰的需求⾛可以⾃⾏实现仿函数传给第⼆个模版参数
- set底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第三个参数。
- ⼀般情况下，我们都不需要传后两个模版参数
- set底层是⽤红⿊树实现，增删查效率是 O(logN) ，迭代器遍历是⾛的搜索树的中序，所以是有序的。
- 前⾯部分我们已经学习了vector/list等容器的使⽤，STL容器接⼝设计，⾼度相似，所以这⾥我们就不再⼀个接⼝⼀个接⼝的介绍，⽽是直接带着⼤家看⽂档，挑⽐较重要的接⼝进⾏介绍。
cpp
template < class T,
// set::key_type/value_type
class Compare = less<T>,
// set::key_compare/value_compare
class Alloc = allocator<T>
// set::allocator_type
> class set;2.3 set的构造和迭代器
set的构造我们关注以下⼏个接⼝即可。
set的⽀持正向和反向迭代遍历，遍历默认按升序顺序，因为底层是⼆叉搜索树，迭代器遍历⾛的中序；⽀持迭代器就意味着⽀持范围for，set的iterator和const_iterator都不⽀持迭代器修改数据，修改关键字数据，破坏了底层搜索树的结构。
2.4 set的增删查
set的增删查关注以下⼏个接⼝即可：
cpp
Member types
key_type
->The first template parameter(T)
value_type->The first template parameter(T)
// 单个数据插⼊，如果已经存在则插⼊失败
pair<iterator, bool> insert(const value_type& val);
// 列表插⼊，已经在容器中存在的值不会插⼊
void insert(initializer_list<value_type> il);
// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert(InputIterator first, InputIterator last);
// 查找val，返回val所在的迭代器，没有找到返回end()
iterator find(const value_type& val);
// 查找val，返回Val的个数
size_type count(const value_type& val) const;
// 删除⼀个迭代器位置的值
iterator erase(const_iterator position);
// 删除val，val不存在返回0，存在返回1
size_type erase(const value_type& val);
// 删除⼀段迭代器区间的值
iterator erase(const_iterator first, const_iterator last);
// 返回⼤于等val位置的迭代器
iterator lower_bound(const value_type& val) const;
// 返回⼤于val位置的迭代器
iterator upper_bound(const value_type& val) const;2.5 insert和迭代器遍历使用样例
cpp
void test_set1()
{
set<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(5);
s.insert(3);
s.insert(5);
s.insert(6);
// 遍历结果
set<int>::iterator it = s.begin();
while (it != s.end())
{
cout << *it << endl;
++it;
}
cout << endl;
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
int x = 0;
cin >> x;
cout << s.erase(x) << endl;
// 单纯判断在不在
if (s.count(x))
{
}
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
2.6 find和erase使用样例：
cpp
void test_set2()
{
set<int> s;
//s.insert(3);
s.insert(1);
s.insert(2);
s.insert(5);
//s.insert(3);
s.insert(5);
s.insert(6);
s.insert(7);
s.insert(9);
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
// 删除[3, 8]区间值
// >= 3
auto it1 = s.lower_bound(3); // 带等号
// > 8
auto it2 = s.upper_bound(8); // 不带等号
s.erase(it1, it2); // 一般都是前闭后开
for (auto e : s)
{
cout << e << " ";
}
}
2.7 multiset和set的差异
multiset和set的使⽤基本完全类似，主要区别点在于multiset⽀持值冗余，那么
insert/find/count/erase都围绕着⽀持值冗余有所差异，具体参看下⾯的样例代码理解。
cpp
void test_set3()
{
multiset<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(5);
s.insert(3);
s.insert(5);
s.insert(6);
s.insert(3);
s.insert(3);
// 相⽐set不同的是，multiset是排序，但是不去重
multiset<int>::iterator it = s.begin();
while (it != s.end())
{
// *it = 1; // 不能修改,set里的值不能修改
cout << *it << " ";
++it;
}
cout << endl;
// 相⽐set不同的是，x可能会存在多个，find查找中序的第⼀个
auto pos = s.find(3);
while (pos != s.end() && *pos == 3)
{
cout << *pos << " ";
++pos;
}
cout << endl;
// [)
//std::pair<multiset<int>::iterator, multiset<int>::iterator> ret = s.equal_range(3);
auto ret = s.equal_range(3);
cout << s.count(3) << endl;
cout << s.erase(3) << endl;
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
2.8 set相关算法题
①环形链表 II - ⼒扣（LeetCode）
数据结构初阶阶段，我们通过证明⼀个指针从头开始⾛⼀个指针从相遇点开始⾛，会在⼊⼝点相遇，理解证明都会很⿇烦。这⾥我们使⽤set查找记录解决⾮常简单⽅便，这⾥体现了set在解决⼀些问题时的价值，完全是降维打击.
算法思路：创建一个set，遍历链表，如果该结点不在set中，将该结点insert到set中，若该结点在链表中，则返回该链表结点，表明该结点为环形链表入口
cpp
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
set<ListNode*> s;
ListNode* cur = head;
while(cur)
{
auto it = s.find(cur);
// 指向容器最后一个元素之后的位置
if(it == s.end())
{
//该元素不在，插入
s.insert(cur);
}
else
{
return *it;
}
cur = cur->next;
}
return nullptr;
}
};②两个数组的交集
算法思路：
先用set将两个数组进行去重操作，得到s1和s2，创建两个指针，分别指向s1和s2最开始的位置，比较两个数字的大小，哪个小，移动哪个指针；创建一个存交集的数组result，若遇到相等元素，则将该元素插入result数组中，重复该操作，直到s1和s2遍历结束
cpp
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
set<int> s1(nums1.begin(), nums1.end());
set<int> s2(nums2.begin(), nums2.end());
auto it1 = s1.begin();
auto it2 = s2.begin();
vector<int> result;
while(it1 != s1.end() && it2 != s2.end())
{
if(*it1 > * it2)
{
// 小的指针往后移
it2++;
}
else if(*it1 < *it2)
{
it1++;
}
else{
result.push_back(*it1);
it1++;
it2++;
}
}
return result;
}
};3. map系列的使用
3.1 map和multimap参考文档
3.2 map类的介绍
map的声明如下，Key就是map底层关键字的类型，T是map底层value的类型，set默认要求Key支持小于⽐较，如果不⽀持或者需要的话可以⾃⾏实现仿函数传给第⼆个模版参数，map底层存储数据的内存是从空间配置器申请的。⼀般情况下，我们都不需要传后两个模版参数。map底层是用红黑树实现，增删查改效率是 O(logN) ，迭代器遍历是⾛的中序，所以是按key有序顺序遍历的。
3.3 pair类型介绍
map底层的红⿊树节点中的数据，使⽤**pair<Key, T>**存储键值对数据。
pair有first和second的两个成员变量
3.4 map的构造
map的构造我们关注以下几个接口即可。
map支持正向和反向迭代遍历，遍历默认按key的升序顺序，因为底层是⼆叉搜索树，迭代器遍历⾛的中序；⽀持迭代器就意味着⽀持范围for，map⽀持修改value数据，不⽀持修改key数据，修改关键字数据，破坏了底层搜索树的结构。
3.5 map的增删查
map的增删查关注以下⼏个接⼝即可：
map增接⼝，插⼊的pair键值对数据，跟set所有不同，但是查和删的接⼝只⽤关键字key跟set是完全类似的，不过find返回iterator，不仅仅可以确认key在不在，还找到key映射的value，同时通过迭代还可以修改value
3.6 map的数据修改
前⾯提到map⽀持修改mapped_type 数据，不⽀持修改key数据，修改关键字数据，破坏了底层搜
索树的结构。
map第⼀个⽀持修改的方式时通过迭代器，迭代器遍历时或者find返回key所在的iterator修改，map还有⼀个⾮常重要的修改接⼝operator[]，但是operator[]不仅仅⽀持修改，还⽀持插⼊数据和查找数据，所以他是⼀个多功能复合接口
需要注意从内部实现⻆度，map这⾥把我们传统说的value值，给的是T类型，typedef为
mapped_type。而value_type是红⿊树结点中存储的pair键值对值。⽇常使⽤我们还是习惯将这⾥的T映射值叫做value。
insert插⼊⼀个pair<key, T>对象
1、如果key已经在map中，插⼊失败，则返回⼀个pair<iterator,bool>对象，返回pair对象
first是key所在结点的迭代器，second是false
2、如果key不在在map中，插⼊成功，则返回⼀个pair<iterator,bool>对象，返回pair对象
first是新插⼊key所在结点的迭代器，second是true也就是说⽆论插⼊成功还是失败，返回pair<iterator,bool>对象的first都会指向key所在的迭
代器
那么也就意味着insert插⼊失败时充当了查找的功能，正是因为这⼀点，insert可以⽤来实现
operator[]
需要注意的是这⾥有两个pair，不要混淆了，⼀个是map底层红⿊树节点中存的pair<key, T>，另
⼀个是insert返回值pair<iterator,bool>
cpp
pair<iterator, bool> insert(const value_type& val);
mapped_type& operator[] (const key_type& k);
// operator的内部实现
mapped_type& operator[] (const key_type& k)
{
// 1、如果k不在map中，insert会插入k和mapped_type默认值，同时[]返回结点中存储
// mapped_type值的引用，那么我们可以通过引用修改返映射值。所以[]具备了插入 + 修改功能
// 2、如果k在map中，insert会插入失败，但是insert返回pair对象的first是指向key结点的
//迭代器，返回值同时[]返回结点中存储mapped_type值的引用，所以[]具备了查找 + 修改的功能
pair<iterator, bool> ret = insert({ k, mapped_type() });
iterator it = ret.first;
return it->second;
}operator等价于下式（另一种形式的底层实现）：
3.7 构造遍历及增删查使用样例
cpp
void test_map1()
{
map<string, string> dict;
// c++98
pair<string, string> kv1("sort", "排序");
dict.insert(kv1);
dict.insert(pair<string, string>("left", "左边")); // 匿名对象
dict.insert(make_pair("left", "左边"));
// C++11
dict.insert({ "right", "右边" });
//dict.insert({ kv1, pair<string, string>("left","左边") });
dict.insert({ {"string", "字符串"}, {"map", "地图，映射"} });
// key相同就不会再插入，value不相同也不会插入
dict.insert({ "left", "左边xxx" });
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
//cout << (*it).first << ":" << (*it).second << endl;
cout << it->first << ":" << it->second << endl;
//cout << it.operator->()->first << ":" << it.operator->()->second << endl;
++it;
}
cout << endl;
//支持迭代器就支持for循环
for (auto& e : dict)
{
cout << e.first << ":" << e.second << endl;
}
cout << endl;
// 结构化绑定 C++17
auto[x, y] = kv1;
//for(auto[k, v] : dict)
//for(auto& [k, v] : dict)
for (const auto [k, v] : dict)
{
cout << k << ":" << v << endl;
}
cout << endl;
auto pos = dict.find("left");
if (pos != dict.end())
{
dict.erase(pos);
}
for (const auto& [k, v] : dict)
{
cout << k << ":" << v << endl;
}
cout << endl;
}C++17中有的新语法：结构化绑定
3.8 map的迭代器和[]功能样例
cpp
void test_map2()
{
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> countMap;
// 不用opeator[]的写法
for (auto& e : arr)
{
auto it = countMap.find(e);
// 已经插入了，次数+1
if (it != countMap.end())
{
it->second++;
}
// 还未插入，插入
else
{
countMap.insert({ e, 1 });
}
}
// 使用opeator[]的写法
for (auto& e : arr)
{
countMap[e]++;
}
for (auto& [k, v] : countMap)
{
cout << k << ":" << v << endl;
}
// operator[]的用法示例代码
map<string, string> dict;
//插入
dict["sort"];
// 插入+修改
dict["left"] = "左边";
// 修改
dict["sort"] = "排序";
//查找
cout << dict["sort"] << endl;
// 纯粹的查找+修改
//at
dict.at("left") = "xxxxx";
//key不存在，会抛异常，不能插入
/*dict.at("insert") = "xxxxx";*/
}
3.9 multimap和map的差异
multimap和map的使用基本完全类似，主要区别点在于multimap支持关键值key冗余，那么
insert/find/count/erase都围绕着支持关键值key冗余有所差异，这里跟set和multiset完全一样，比如find时，有多个key，返回中序第一个 。其次就是multimap不支持[]，因为支持key冗余，[]就只能支持插入了，不能支持修改。
cpp
void test_map3()
{
multimap<string, string> dict;
dict.insert({ "right", "右边" });
dict.insert({ "left", "左边" });
dict.insert({ "right", "右边xx" });
dict.insert({ "right", "右边" });
for (const auto& [k, v] : dict)
{
cout << k << ":" << v << endl;
}
cout << endl;
}
3.10 map相关的算法题
算法思想：
先复制原来的链表为s，用一个容器map，key值为原链表，映射的T为复制后的链表s，遍历原始链表，根据映射值将复制后的链表s的指针指向修改。
cpp
class Solution {
public:
Node* copyRandomList(Node* head) {
map<Node*, Node*> nodeMap;
Node* copyhead = nullptr;
Node* copytail = nullptr;
Node* cur = head;
while(cur)
{
if(copytail == nullptr)
{
Node* tmp = new Node(cur->val);
copytail = copyhead = tmp;
}
else
{
Node* tmp = new Node(cur->val);
copytail->next = tmp;
copytail = copytail->next;
}
//将原节点和拷贝结点map kv存储
nodeMap[cur] = copytail;
cur = cur -> next;
}
cur = head;
Node* copy = copyhead;
while(cur)
{
if(cur->random == nullptr)
{
copy->random = nullptr;
}
else{
copy->random = nodeMap[cur->random];
}
copy = copy->next;
cur = cur->next;
}
return copyhead;
}
};本题目我们利用map统计出次数以后，返回的答案应该按单词出现频率由高到低排序，有一个特殊要求，如果不同的单词有相同出现频率，按字典顺序排序。
算法思路1：
用排序找前k个单词，因为map中已经对key单词排序过，也就意味着遍历map时，次数相同的单词，字典序小的在前面，字典序大的在后面。那么我们将数据放到vector中用一个稳定的排序就可以实现上面特殊要求，但是sort底层是快排，是不稳定的，所以我们要用stable_sort，他是稳定的。
cpp
class Solution {
public:
struct Compare
{
bool operator()(const pair<string, int>& x, const pair<string, int>& y) const
{
return x.second > y.second;
}
};
vector<string> topKFrequent(vector<string>& words, int k) {
map<string, int> countMap;
for(auto& e : words)
{
countMap[e]++;
}
vector<pair<string, int>> v(countMap.begin(), countMap.end());
// 仿函数控制降序
stable_sort(v.begin(), v.end(),Compare());
vector<string> result;
for(int i = 0; i < k; ++i)
{
result.push_back(v[i].first);
}
return result;
}
};这里的stable_sort可以改成sort，然后在Compare中改为：
cpp
struct Compare
{
bool operator()(const pair<string, int>& x, const pair<string, int>& y)
const
{
return x.second > y.second || (x.second == y.second && x.first <
y.first);;
}
};算法思路2：
将map统计出的次数的数据放到优先级队列priority_queue中来选出前k个。利用仿函数强行控制次数相等的，字典序小的在前面。
cpp
#include<queue>
class Solution {
public:
struct Compare
{
// 大堆提供的小于的比较逻辑
bool operator()(const pair<string ,int>& x, const pair<string, int>& y) const
{
return x.second < y.second || (x.second == y.second && x.first > y.first);
}
};
vector<string> topKFrequent(vector<string>& words, int k) {
map<string, int> countMap;
for(auto& e: words)
{
countMap[e]++;
}
priority_queue< pair<string, int>, vector<pair<string, int>>, Compare> pq(countMap.begin(), countMap.end());
vector<string> result;
for(int i = 0; i < k; i++)
{
result.push_back(pq.top().first);
pq.pop();
}
return result;
}
};输入一个英文句子，把句子中的单词(不区分大小写)按出现次数按从多到少把单词和次数在屏幕上输出来，要求能识别英文句号和逗号，即是说单词由空格、句号和逗号隔开。
cpp
#include <iostream>
using namespace std;
#include<map>
#include<vector>
#include<algorithm>
bool cmp(pair<string, int>& x, pair<string, int>& y)
{
return x.second > y.second || (x.second == y.second && x.first < y.first);
}
int main() {
// 获取这个句子
string s;
map<string, int> countMap;
while(getline(cin, s))
{
for(int i = 0, j = 0; i < s.size(); i++)
{
if(s[i] == ' ' || s[i] == '.')
{
// j指示一个单词的首字母
string word = s.substr(j, i - j);
j = i + 1;
// 变小写
if(isupper(word[0]))
{
word[0] = tolower(word[0]);
}
countMap[word]++;
}
}
}
vector<pair<string, int>> v(countMap.begin(), countMap.end());
sort(v.begin(), v.end(), cmp);
for(auto& e : v)
{
cout << e.first << ":" << e.second << endl;
}
cout << endl;
}