目录
一、前言
二、预备知识
💢关联式容器💢
💢键值对💢
💢哈希结构的关联式容器💢
三、map 详解
🔥map 的介绍
🔥map的模板参数说明
🔥map的构造函数
🔥map的使用
🍇 insert
🍐 operator [ ]
🥝 find
🍍 erase
🍉 swap
🍈 empty
🍌 size
🍋 count
🔥 总结
四、常考面试题
五、共勉
一、前言
【map】是STL中的容器之一，不同于普通容器，它的查找速度极快，常用来存储各种经常被检索的数据，因为容器的底层是【红黑树】。除此之外，还可以借助其特殊的性质，解决部分难题。
二、预备知识
在正式学习 map 之前，首先要有一些预备知识，否则后面可能看不懂相关操作
💢关联式容器💢
在以往的 【
STL容器】学习中，我们接触到的都是 序列式容器，比如string、vector、list、deque等，序列式容器的特点就是 底层为线性序列的数据结构，就比如list，其中的节点是 线性存储 的，一个节点存储一个元素，其中存储的元素都可序，但未必有序
- 【关联式容器】 则比较特殊，其中存储的是
<key, value>的 键值对，这就意味着可以按照 键值大小key以某种特定的规则放置于适当的位置，关联式容器 没有首尾的概念，因此没有头插尾插等相关操作，本文中学习的 map 就属于 关联式容器
注意： stack、queue 等适配器也属于序列式容器，因为他们的底层是 deque 等容器
💢键值对💢
【键值对】是 一种用来表示具有一一对应关系的结构，该结构中一般只包含两个成员变量：
key和value，前者表示 键值，后者表示 实值 关联式容器的实现离不开【键值对】
- 因此在标准库中，专门提供了这种结构
pair定义如下 ：
//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) {}
#ifdef __STL_MEMBER_TEMPLATES
template <class U1, class U2>
pair(const pair<U1, U2>& p) : first(p.first), second(p.second) {}
#endif
};pair中的first表示 键值，second则表示 实值，在给 【关联式容器】 中插入数据时，可以构建pair对象
比如下面就构建了一个 键值
key为string，实值value为int的匿名 键值对pair对象
pair<string, int>("hehe", 123);
- 可以将此匿名对象传入 关联式容器 中，当然这样写未免过于麻烦了，于是库中设计了一个函数模板
make_pair，可以根据传入的参数，去调用pair构建对象并返回
make_pair("hehe", 123); //构建出的匿名对象与上面的一致
make_pair的定义如下所示：
template <class T1,class T2>
pair<T1,T2> make_pair (T1 x, T2 y)
{
return ( pair<T1,T2>(x,y) );
}- 该函数实际会被编译器优化为 内联函数，因此不会造成过多消耗，可以放心使用
💢哈希结构的关联式容器💢
所以在
C++标准中，共提供了四种 哈希结构的关联式容器
unordered_setunordered_multisetunordered_mapunordered_multimap
关于 树形结构的关联式容器 将在 二叉搜索树 中学习
树型结构与哈希结构的关联式容器功能都是一模一样的，不过 哈希结构查找比树型结构快得多 -> O(1)
注：
STL中选择的树型结构为 红黑树RB-Tree- 树型结构中的元素 中序遍历 后有序，而哈希结构中的元素无序
三、map 详解
在C++98中，STL提供了底层为 红黑树结构 的一系列关联容器，在查询时效率可以达到 log(N)。但是在较差的情况下 ，需要比较红黑树的高度次，当树中节点非常多的时候，查询效率也会不理想达到 log(N)
- 接下来我们将会对，map 进行详细的介绍，其余的容器将会在后续的文章中讲述。
🔥map 的介绍
map是关联容器，它按照特定的次序（按照key来比较）存储 由键值 key 和值 value 组合而成的元素。
- 在map中，键值 key 通常用于排序和唯一的标识元素，而 value 中存储的值与键值 key 产生关联。键值 key 和值 value 的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起， 为其取别名称为pair::typedef pair value_type;
- 在内部，map中的元素总是按照键值key进行比较排序的。
- map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行 直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
- map支持下标访问符，即在 [ ] 中放入key，就可以找到与key对应的value。
- map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))
🔥map的模板参数说明
如下图所示：
- key: 键值对中 key 的类型
- T：键值对中 value 的类型
- Compare: 比较器的类型，map 中的元素是按照 key 来比较的，缺省情况下按照小于来比较，一般情况 下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则 (一般情况下按照函数指针或者仿函数来传递)
- Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
注意：在使用map时，需要包含头文件。
#include <map>🔥map的构造函数
主要有下面三个构造方式：
（1）指定 key 和 value 的类型构造一个空容器
// 构造一个key为string类型，value为int类型的空容器
map<string, int> m1;
（2）拷贝构造某类型容器
// 拷贝构造key为string类型，value为int类型的m1容器的复制品
map<string, int> m2(m1);
（3）使用迭代器区间进行初始化构造
// 使用迭代器拷贝构造m2容器某段区间的复制品
map<string, int> m3(m2.begin(), m2.end());
简单的使用一下：
#include <iostream>
#include <vector>
#include <map>
using namespace std;
int main()
{
vector<pair<string, int>> arr = { make_pair("G", 71), make_pair("A", 65), make_pair("F", 70) };
map<string, int> m1; //创建一个空的 map
map<string, int> m2(arr.begin(), arr.end()); //创建包含数据的 map
cout << "m1: " << endl;
for (auto e : m1)
cout << e.first << " | " << e.second << endl;
cout << "========================" << endl;
cout << "m2: " << endl;
for (auto e : m2)
cout << e.first << " | " << e.second << endl;
return 0;
}
🔥map的使用
map 的接口虽然比较多，但是常用的也就那么几个
🍇 insert
在 map 中插入键值对 x ，注意 x 是一个键值对，返回值也是键值对
- iterator 代替新插入元素的位置，bool 代表是否插入成功
- 在 map 的内部，key 与 value 通过成员类型 value_type 绑定在一起，为其取别名称为 pair
typedef pair<const key, T> value_type;
- 下面对于 insert 的插入有两种方式
（1）直接使用 pair 直接来构建键值对
void testmap()
{
map<string, string> dict;
// 调用pair的构造函数，构造一个匿名对象插入
dict.insert(pair<string, string>("sort", "排序"));
dict.insert(pair<string, string>("root", "根"));
dict.insert(pair<string, string>("left", "左边"));
// 遍历
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
}
- 可以看到插入的英文是按照升序进行排列的。
（2）使用 make_pair 函数来构造键值对
- 构造一个第一个元素设为 x ，第二个元素设为 y 的 pair 对象
- 模板类型可以传递给 make_pair 的参数隐式推到出来
- 如果各自类型可以隐式转换，则可以从包含不同类型的其它 pair 对象构造 pair 对象
void testmap()
{
map<string, string> dict;
// 调用make_pair的构造函数，构造一个匿名对象插入
dict.insert(make_pair("sort", "排序"));
dict.insert(make_pair("root", "根"));
dict.insert(make_pair("left", "左边"));
dict.insert(make_pair("up", "上面"));
// 遍历
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
}
- 推荐使用这个方式插入数据
（3）统计水果出现的次数
既然已经知道 insert 的用法，我就用 map 来统计一下水果出现的次数
void testmap()
{
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> countFruit;
for (auto& str : arr)
{
map<string, int>::iterator it = countFruit.find(str);
if (it != countFruit.end())
{
it->second++;
}
else
{
countFruit.insert(make_pair(str, 1));
}
}
// 遍历
for (const auto& kv : countFruit)
{
cout << kv.first << ":" << kv.second << endl;
}
}
- 可以看出 水果的次数已经被打印出来啦
但是代码还是可以进行优化，我们知道 insert 的返回值是 pair<iterator，bool>：
其中第一个成员 iterator （pair::first）是指向新插入元素或映射中具有等效键的元素迭代器。
第二个成员 bool （pair::second）是返回插入成功与否的结果
- 若待插入元素的键值 key 在 map 当中不存在，则 insert 函数插入成功，并返回插入后元素的迭代器和 true。
- 若待插入元素的键值 key 在 map 当中已经存在，则 insert 函数插入失败，并返回 map 当中键值为 key 的元素的迭代器和 false。
void testmap()
{
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> countFruit;
for (auto& str : arr)
{
pair<map<string, int>::iterator, bool> ret = countFruit.insert(make_pair(str, 1));
// auto ret = countFruit.insert(make_pair(str, 1)); // 也可以写成auto
if (ret.second == false)
{
ret.first->second++; // ret.first是插入位置的迭代器,通过迭代器去访问second
}
}
// 遍历
for (const auto& kv : countFruit)
{
cout << kv.first << ":" << kv.second << endl;
}
}
- 运行可以看到结果是一样的
🍐 operator [ ]
返回 key 对应的 value :
- 如果 k 与容器中元素的键匹配，则函数返回对其映射值得引用。
- 如果 k 与容器中任何元素得键不匹配，该函数将插入一个具有该键得新元素，并返回对其映射值得引用。
对这个函数的调用相当于：
(*((this->insert(make_pair(k,mapped_type()))).first))
operator[ ] 的原理就是：
- 用 <key，T()> 构造一个键值对，然后调用 insert() 函数将该键值对插入到 map 中
- 如果 key 已经存在，插入失败，insert 函数返回该 key 所在位置的迭代器
- 如果 key 不存在，插入成功，insert 函数返回新插入元素所在位置的迭代器
- operator[ ] 函数最后将 insert 返回值键值对中的 value 返回
void testmap()
{
map<string, string> dict;
// 用make_pair函数来构造键值对
dict.insert(make_pair("sort", "排序"));
dict.insert(make_pair("root", "根"));
dict.insert(make_pair("left", "左边"));
dict["up"] = "向上"; // up不存在,那么就插入up元素并修改(插入+修改)
dict["left"] = "剩余"; // left存在,那么只修改(查找+修改)
dict["erase"]; // erase不存在,那么插入
// 遍历
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
}
- 对于上面统计水果的次数，其实比较常用的就是 operator[ ]
void testmap()
{
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> countFruit;
for (auto& str : arr)
{
countFruit[str]++;
}
// 遍历
for (const auto& kv : countFruit)
{
cout << kv.first << ":" << kv.second << endl;
}
}
- 如果水果是第一次出现，那么就先插入，因为是第一次出现， 所以水果的次数为 0，插入成功以后，会把插入的这个水果所在的节点里面的次数进行引用返回，也就是返回 0 的引用，那么此时进行++，变成 1 。
- 如果水果是第二次出现，那么不会插入成功，那么就直接返回这个水果所在的节点迭代器里面的次数,然后再进行++变成 2。
注意：这里的 [ ] 不支持随机访问 ！
🥝 find
在容器中搜索键值等于 k 的元素,如果找到则返回该元素的迭代器，否则返回map::end的迭代器。
void testmap()
{
map<string, string> dict;
// 用make_pair函数来构造键值对
dict["sort"] = "排序";
dict["up"] = "向上";;
dict["left"] = "左边";
dict["root"] = "根";
auto pos = dict.find("root");
if (pos != dict.end())
{
cout << "找到了" << endl;
cout << pos->first << ":" << pos->second << endl;
}
}
🍍 erase
从 map 容器中移除单个元素或一组元素
（1）从 map 容器中移除单个元素
void testmap()
{
map<string, string> dict;
// 用make_pair函数来构造键值对
dict["sort"] = "排序";
dict["up"] = "向上";;
dict["left"] = "左边";
dict["root"] = "根";
auto pos = dict.find("root");
if (pos != dict.end())
{
dict.erase(pos);
cout << "删除成功" << endl;
}
// 遍历
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
}
（2）从 map 容器中移除一组元素（【first，last））
void testmap()
{
map<string, string> dict;
// 用make_pair函数来构造键值对
dict["sort"] = "排序";
dict["up"] = "向上";;
dict["left"] = "左边";
dict["root"] = "根";
auto pos = dict.find("root");
if (pos != dict.end())
{
dict.erase(pos, dict.end()); // 删除从pos位置开始后面所有的元素
cout << "删除成功" << endl;
}
// 遍历
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
}
- 可以看到 root 后面的元素已经删掉了
🍉 swap
交换 map 容器中的元素
void testmap()
{
map<string, string> dict1;
dict1["sort"] = "排序";
dict1["up"] = "向上";;
dict1["left"] = "左边";
dict1["root"] = "根";
map<string, string> dict2;
dict2["size"] = "大小";
dict2["erase"] = "删除";
dict2["clear"] = "清除";
dict2["insert"] = "插入";
dict1.swap(dict2); // 交换两个对象中的元素
for (auto e1 : dict1)
{
cout << e1.first << ":" << e1.second << endl;
}
cout << endl;
for (auto e2 : dict2)
{
cout << e2.first << ":" << e2.second << endl;
}
}
- 可以看到两个对象的元素已经被交换
🍈 empty
检测 map 中的元素是否为空，是返回 true，否则返回 false
void testmap()
{
map<string, string> dict1;
dict1["sort"] = "排序";
dict1["up"] = "向上";
dict1["left"] = "左边";
dict1["root"] = "根";
map<string, string> dict2;
cout << dict1.empty() << endl; // 不为空,返回false
cout << dict2.empty() << endl; // 为空,返回true
}
🍌 size
返回 map 中的有效元素个数
void testmap()
{
map<string, string> dict;
dict["sort"] = "排序";
dict["up"] = "向上";
dict["left"] = "左边";
dict["root"] = "根";
cout << dict.size() << endl;
}
🍋 count
获取 map 容器中指定 k 值的元素个数
void testmap()
{
map<string, string> dict;
dict["sort"] = "排序";
dict["up"] = "向上";
dict["left"] = "左边";
dict["root"] = "根";
cout << dict.count("root") << endl; // root的个数
cout << dict.count("hello") << endl; // hello的个数
}
- 这个接口对于 map 容器其实没有太大用处，因为 map 当中的每个键值 key 和值 value 都是唯一的。
🔥 总结
- map 中的元素是键值对
- map 中的 key 是唯一的，并且不能修改
- 默认按照小于的方式对 key 进行比较
- map 中的元素如果用迭代器去遍历，可以得到一个有序的序列
- map 的底层为平衡搜索树（红黑树），查找效率比较高 O(logN)
- 支持 [ ] 操作符，operator[ ] 中实际进行插入查找
四、常考面试题
题目描述：前 K 个高频单词
题目链接：692. 前K个高频单词 - 力扣（LeetCode）
- 利用
map建立<string, int>的映射关系，在按照字典序排序的同时统计出每个单词的出现频率，再通过快排依照数量进行二次排序，选择前k个高频单词即可 - 只需要将 仿函数进行设计即可：优先按照出现频率排序，如果频率相同，则按照字典序排序即可
//map + sort
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
//统计每个单词出现的频率，同时先按照字典序排序
map<string, int> table;
for(auto e : words)
table[e]++;
//将处理好的数据存入数组中
vector<pair<string, int>> vTable(table.begin(), table.end());
//按照出现频率进行二次排序
sort(vTable.begin(), vTable.end(),
[](const pair<string, int>& kv1, const pair<string, int>& kv2)->bool
{
return kv1.second == kv2.second ? kv1.first < kv2.first : kv1.second > kv2.second;
});
//取出前 k 个高频单词
vector<string> vs;
for(int i = 0; i < k; i++)
vs.push_back(vTable[i].first);
return vs;
}
};
五、共勉
以下就是我对 【C++】map 容器 的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新【C++】，请持续关注我哦！！！
