map详解（C++）

属于你的愿与愁

于 2025-03-17 14:14:10 发布

阅读量2.3k

点赞数 41

分类专栏：学习C++ 文章标签： c++ 开发语言算法学习

本文链接：https://blog.csdn.net/weixin_47271425/article/details/146046736

版权

学习C++ 专栏收录该内容

17 篇文章

订阅专栏

1. 前言

【map】 是 STL 中的容器之一，不同于普通容器，它的查找速度极快，常用来存储各种经常被检索的数据，因为容器的底层是【红黑树】。除此之外，还可以借助其特殊的性质，解决部分难题。

2. 预备知识

在正式学习 map 之前，首先要有一些预备知识，否则后面可能看不懂相关操作

2.1 关联式容器

在以往的【STL 容器】学习中，我们接触到的都是 序列式容器，比如 string、vector、list、deque 等，序列式容器的特点就是 底层为线性序列的数据结构，就比如 list，其中的节点是 线性存储 的，一个节点存储一个元素，其中存储的元素都可序，但未必有序

【关联式容器】 则比较特殊，其中存储的是 <key, value> 的 键值对，这就意味着可以按照 键值大小 key 以某种特定的规则放置于适当的位置，关联式容器 没有首尾的概念，因此没有头插尾插等相关操作，本文中学习的 map 就属于 关联式容器

注意： stack、queue 等适配器也属于序列式容器，因为他们的底层是 deque 等容器

2.2 键值对

【键值对】是 一种用来表示具有一一对应关系的结构，该结构中一般只包含两个成员变量：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) );
  }

该函数实际会被编译器优化为 内联函数，因此不会造成过多消耗，可以放心使用

3. map详解

使用map需要包含头文件include <map>

3.1 map介绍

map是关联容器，它按照特定的次序（按照key来比较）存储由键值 key 和值 value 组合而成的元素

在map中，键值 key 通常用于排序和唯一的标识元素，而 value 中存储的值与键值 key 产生关联。键值 key 和值 value 的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair::typedef pair value_type;
内部，map中的元素总是按照键值key进行比较排序的。
map支持下标访问符，即在 [ ] 中放入key，就可以找到与key对应的value。
map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树)）

3.2 map的模板参数说明

key: 键值对中 key 的类型
T：键值对中 value 的类型
Compare: 比较器的类型，map 中的元素是按照 key 来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则 (一般情况下按照函数指针或者仿函数来传递)
Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器

3.3 map的构造函数

（1）指定 key 和 value 的类型构造一个空容器

// 构造一个key为string类型，value为int类型的空容器
map<string, int> m1;

（2）使用迭代器区间进行初始化构造

// 使用迭代器拷贝构造m2容器某段区间的复制品
map<string, int> m3(m2.begin(), m2.end());

（3）拷贝构造某类型容器

// 拷贝构造key为string类型，value为int类型的m1容器的复制品
map<string, int> m2(m1);

#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;
}

3.4 map使用

map 的接口虽然比较多，但是常用的也就那么几个

3.4.1 insert

在 map 中插入键值对 val ，注意 val 是一个键值对，返回值也是键值对

iterator 代替新插入元素的位置，bool 代表是否插入成功
在 map 的内部，key 与 value 通过成员类型 value_type 绑定在一起，为其取别名称为 pair
下面对于 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", "左边"));
	//有名对象插入
	pair<string, string> s1("right", "右边");
	dict.insert(s1);

	// 遍历
	for (auto e : dict)
	{
		cout << e.first << ":" << e.second << endl;
	}
}

可以看到插入的英文是按照升序进行排列的。

（2）使用 make_pair 函数来构造键值对

构造一个第一个元素设为 x ，第二个元素设为 y 的 pair 对象
模板类型可以传递给 make_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）使用 {} 走来构造键值对

用{}构造的方法叫做列表初始化，本质还是调用map中pair中的构造函数构造的

void testmap()
{
	map<string, string> dict;

	dict.insert({ "sort", "排序" });
	dict.insert({ "root", "根" });
	dict.insert({ "left", "左边" });
	dict.insert({ "up", "上面" });

	// 遍历
	for (auto e : dict)
	{
		cout << e.first << ":" << e.second << endl;
	}
}

最推荐使用这个方式插入数据

（4）统计水果出现的次数

既然已经知道 insert 的用法，我就用 map 来统计一下水果出现的次数

void testmap()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countFruit;
	for (const auto& str : arr)
	{
		auto it = countFruit.find(str);
		if (it == countFruit.end())
		{
			countFruit.insert({ str,1 });
		}
		else
		{
			it->second++;
		}
	}
	//遍历
	for (const auto& e : countFruit)
	{
		cout << e.first << "：" << e.second << endl;
	}
}

程序运行结果：

但是代码还是可以进行优化，我们知道 insert 的返回值是 pair<iterator，bool>：

其中第一个成员 iterator （pair::first）是指向新插入元素或映射中具有等效键的元素迭代器

第二个成员 bool （pair::second）是返回插入成功与否的结果

若待插入元素的键值 key 在 map 当中不存在，则 insert 函数插入成功，并返回新插入位置的迭代器和 true。
若待插入元素的键值 key 在 map 当中已经存在，则 insert 函数插入失败，并返回找到元素位置的迭代器和 false。

void testmap()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countFruit;
	for (const auto& str : arr)
	{
		auto it = countFruit.insert({ str, 1 });
		//插入失败，就说明map中pair已经有key为一样的值了
		if (it.second == false)
		{
			//所以我们通过it找到指向这个位置的迭代器，并且通过迭代器去修改value
			it.first->second++;
		}
	}
	//遍历
	for (const auto& e : countFruit)
	{
		cout << e.first << "：" << e.second << endl;
	}
}

运行可以看到结果是一样的

3.4.2 operator[ ]

返回 key 对应的 value :

如果 k 与容器中元素的键匹配，则函数返回对其映射值得引用。
如果 k 与容器中任何元素得键不匹配，该函数将插入一个具有该键得新元素，并返回对其映射值得引用。

map::operator[]底层实现图：

如果我们自己用代码实现就如图所示：

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", "左边"));

	//这里的修改指的是修改其value
	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。

注意：这里的 [ ] 不支持随机访问！

3.4.3 find

在容器中搜索键值等于 k 的元素,如果找到则返回该元素位置的迭代器，否则返回map::end的迭代器。

补充点：find在multimapmap中查找值，因为multimap是运行数据冗余的，所以如果查找到k，那找到的一定是中序遍历中的第一个

3.4.4 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"] = "根";

	cout << "删除元素前" << endl;
	// 遍历
	for (auto e : dict)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << endl;

	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 后面的元素已经删掉了

3.4.5 size

返回 map 中的有效元素个数

void testmap()
{
	map<string, string> dict;
	dict["sort"] = "排序";
	dict["up"] = "向上";
	dict["left"] = "左边";
	dict["root"] = "根";
 
	cout << dict.size() << endl;
}

3.4.6 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的个数
}

3.4.7 总结

map 中的元素是键值对
map 中的 key 是唯一的，并且不能修改
默认按照小于的方式对 key 进行比较
map 中的元素如果用迭代器去遍历，可以得到一个有序的序列
map 的底层为平衡搜索树（红黑树），查找效率比较高 O(logN)
支持 [ ] 操作符，operator[ ] 中实际进行插入查找

4. 习题

前K个高频单词

class Solution {
public:

    class cmp
    {
        public:
        bool operator()(const pair<string,int>& s1, const pair<string,int>&  s2)
        {
            //小于是升序，大于是降序
            return (s1.second >s2.second) || ((s1.second ==s2.second) && s1.first < s2.first);
        }
    };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string, int> mp;
        for(const auto& e: words)
        {
            mp[e]++;
        }
    vector<pair<string,int>> v(mp.begin(),mp.end());
    sort(v.begin(),v.end(),cmp());
    int i = 0;
    vector<string> s1;
    for(int i = 0; i < k; i++)
    {
        s1.push_back(v[i].first);
    }
    return s1;
    }
};