【C++】map、set，multiset和multimap的使用及底层原理【完整版】

一、map和set的使用

1、序列式容器和关联式容器

2、set的使用讲解

3、map的使用讲解

二、multiset和multimap

1、multiset和multimap的使用

2、OJ题：前k个高频单词

一、map和set的使用

1、序列式容器和关联式容器

序列式容器：vector/list/string/deque

序列式容器才支持push等操作，关联式容器不支持

关联式容器：map/set/unordered_map/unordered_set

set和map的底层实现是平衡搜索二叉树

2、set的使用讲解

set就是搜索树中的key模型
set的特性：①、会对插入的数据自动排序 ②、set是不允许修改值的 ③、set中不允许出现重复的数值，即使存在，也只会留一个
set的遍历：①、迭代器遍历 ②、范围for遍历（因为支持迭代器遍历就一定支持范围for）
set的拷贝构造
set的插入只有insert，其没有push、pop等，因为它是关联式容器
set的find，find找到了会返回被查找元素的迭代器，没找到返回end()，故应检查找没找到
那set的find和库里面提供的find有什么区别呢？
都可实现查找，区别在于效率
set是搜索二叉树的：时间复杂度：O（logN），而算法中的是O（N）
算法中的find是个模板，其实现是为了所有容器可以通用它，故set尽量用自己的find
set的删除
①、erase(待删除位置的迭代器) ②、erase(待删除数据) ③、erase(s.begin(), s.end())【即迭代器头和尾，其效果等价于clear 】

因为set是key模型，是看在不在，如果把中国所有人的信息存入到set中，最多搜索次数才31次，因为搜索二叉树的效率：O（logN）2^31就=20多亿了，这个效率是非常好的

代码如下：

void test_set()
{
	set<int> s;
	s.insert(3);
	s.insert(1);
	s.insert(4);
	s.insert(3);
	s.insert(7);

	//set : 排序+去重
	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//支持迭代器，就支持范围for
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

	set<int> copy(s);//set的深拷贝
	for (auto& e : copy)
	{
		cout << e << " ";
	}
	cout << endl;

	//auto pos = s.find(3);//可用auto推导类型
	//set<int>::iterator pos = s.find(3);//find查找返回迭代器 
	find找到了会返回元素的迭代器，没找到返回end()
	//if (pos != s.end())
	//{//找到了才能删除
	//	s.erase(pos);//erase会删除迭代器位置的数据
	//}
	//若erase直接给值，若值不存在，也不会报错，但迭代器必须存在那个位置

	set<int>::iterator pos = find(s.begin(), s.end(), 3);//使用算法中的find
	if (pos != s.end())
	{
		s.erase(pos);
	}

	for (auto& e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

运行结果：

3、map的使用讲解

map就是搜索树中的key/value模型
map的遍历：①、迭代器遍历 ②、范围for遍历
map的类型是pair，pair存的一个是key的，一个是value的类型
map的构造函数：①、pair构造函数 ②、make_pair函数模板构造一个pair对象
void test_map1()
{
	map<int, int> m;
	//m.insert(1, 1);//编译不通过
	m.insert(pair<int, int>(1, 1));//pair构造函数，构造一个匿名对象
	m.insert(pair<int, int>(3, 3));
	m.insert(pair<int, int>(2, 2));
	m.insert(make_pair(4, 4));	   //函数模板构造一个pair对象

	map<int, int>::iterator it = m.begin();
	while (it != m.end())
	{	//*it等价于pair,而要访问它的成员
		cout << it->first << ":" << it->second << " " << endl;
		//也可以用(*it).first    (*it).second
		//operator* 返回值是节点中值的引用
		//operator->返回值是节点中值的指针，即pair<k,v>指针
		//本质上为了可读性，这里省略了一个->
		++it; 
	}
	cout << endl;

	for (auto& e : m)
	{//first就是key值，即pair中的第一个值，second就是value值，即pair中的第二个值
		cout << e.first << ":" << e.second << endl;
	}

}
map构造函数两种方法的区别
void test_map2()
{
	//一般写项目不会把std库中的全引进来，而是如下代码，make_pair明显更加简洁
	std::map<std::string, std::string> dict;
	dict.insert(pair<std::string, std::string>("metric", "米制的"));
	dict.insert(make_pair("potent", "强大的"));
	dict.insert(make_pair("deplete", "大量减少"));


	std::map<std::string, std::string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;
}
可见使用make_pair会使代码更简洁

以下是map的应用：统计水果出现的次数【本质是key/value模型的应用】

法一：利用map的find（用key值来查找，而不是value值）
void test_map3()
{
	//用STL中的map怎么统计水果出现的次数呢？
	string strs[] = { "西瓜","樱桃","苹果","西瓜","西瓜","西瓜","西瓜","苹果" };
	map<string, int> countMap;
	for (auto & str : strs)
	{
		map<string, int>::iterator ret = countMap.find(str);
		if (ret != countMap.end())
		{
			ret->second++;//相当于value++
		}
		else
		{
			//第一次出现，直接插入value为1
			countMap.insert(make_pair(str, 1));
		}
	}

	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
}
法二、map的operator[ ]求解

我们之前学的容器只有string，vector和deque才有operator[ ]，而这里map的operator[ ]还有所不同

下面是operator[ ]的底层

可见给operator[ ]一个key值，它返回对应的value值的引用

那就可以把求水果出现的次数代码用operator[ ]实现进一步优化
void test_map3()
{
	//用STL中的map怎么统计水果出现的次数呢？
	string strs[] = { "西瓜","樱桃","苹果","西瓜","西瓜","西瓜","西瓜","苹果" };
	map<string, int> countMap;
	for (auto& str : strs)
	{
		//法二、operator[]实现
		countMap[str]++;//给key值:字符串,返回对应value的引用:次数
	}

	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
}
法三、map的insert求解

operator[ ]的底层是调用insert实现的，故想了解operator[ ]要先了解insert

insert的其中一个版本是
pair<iterator, bool> insert (const value_type& val);
它返回值的意思：

单元素版本：（1）返回pair，其成员pair::first设置为一个迭代器，该迭代器指向新插入的元素或映射中具有等效键的元素。如果插入了新元素，则pair::第二个元素设为true，如果已经存在等效键，则设为false。

理解：

insert对于插入不存在的数据充当插入作用，pair的first指向新插入元素，second设为true，但若插入一个已经存在的数据，insert充当查找作用，pair的first指向之前存在的那个元素，second设为false

利用insert这个版本的特点，我们可以把水果出现的次数再写一个insert的版本
void test_map3()
{
	//用STL中的map怎么统计水果出现的次数呢？
	string strs[] = { "西瓜","樱桃","苹果","西瓜","西瓜","西瓜","西瓜","苹果" };
	map<string, int> countMap;
	for (auto & str : strs)
	{
		//法三、insert实现
		pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(str, 1));
	    //也可写为auto ret = countMap.insert(make_pair(str, 1));
		//如果插入成功，那就说明之前在map中没出现过，value为1即可
		if (ret.second == false)
		{//插入失败，说明之前存在这个数据,迭代器指向之前出现的那个元素
			ret.first->second++;//用迭代器访问到这个元素的value值
		}
	}

	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
}
那insert是如何实现map的operator[]的？

如果水果不在map中，则[ ]会insert插入pair<str, int()> 等价于 pair<str, 0>，那么返回映射对象（次数）的引用就进行了++1
如果水果在map中，则operator[ ]返回水果对应的映射对象（次数）的引用，对它++

下面讲解下map的operator[ ]的多种功能
void test_map3()
{
	//用STL中的map怎么统计水果出现的次数呢？
	string strs[] = { "西瓜","樱桃","苹果","西瓜","西瓜","西瓜","西瓜","苹果" };
	map<string, int> countMap;
	for (auto & str : strs)
	{
		//法二、operator[]实现
		countMap[str]++;//给key值:字符串,返回对应value的引用:次数
	}

	countMap["香蕉"];       //插入,因为第一次出现
	countMap["香蕉"] = 1;   //修改，因为operator[]返回value的引用，故可修改
	cout << countMap["香蕉"] << endl;//查找，因为香蕉已经存在了
	countMap["哈密瓜"] = 5; //插入+修改，哈密瓜第一次出现，并对他的value进行了修改

	map<string, string> dict;
	dict.insert(make_pair("sort", "排序"));
	dict["string"];//key为string，value是string类型的构造函数【因为其是缺省值】，即空串  //插入（一般不会这样用）
	dict["string"] = "字符串";//返回value的引用，可以对其进行修改，能修改是因为返回value的引用 //修改，不算插入因为已存在
	dict["left"] = "左边";//插入+修改，因为"左边"第一次出现，故插入，插入后又对其value进行了修改
	
	for (auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}
}
注：传参只能传key，不能只传value不传key，因为底层是搜索树，搜索树要用key去比较大小，key只要进去了就不能修改了

一般使用operator[]去

插入+修改
修改

一般不会用它去查找，因为如果key不在会插入数据

总结：

二、multiset和multimap

1、multiset和multimap的使用

multiset和multimap除了在set和map的基础上支持数据重复出现外，根本没什么区别

void test_multi()
{
	//与set的区别是允许键值key冗余（重复）
	multiset<int> ms;
	ms.insert(3);
	ms.insert(2);
	ms.insert(3);
	ms.insert(1);
	ms.insert(4);
	ms.insert(5);

	for (auto e : ms)
	{
		cout << e << " ";
	}
	cout << endl;

	auto pos = ms.find(3);
	cout << *pos << endl;
	++pos;
	cout << *pos << endl;
	++pos;

	//multi_map和map的区别和set与multi_set的区别一样
	//额外区别是muti_map没有operator[]，因为当有多个相同的可以时，不知道返回哪个key对应的value
	multimap<string, int> mm;
	mm.insert(make_pair("苹果", 1));
	mm.insert(make_pair("苹果", 1));
	mm.insert(make_pair("苹果", 3));
	mm.insert(make_pair("西瓜", 2));
	mm.insert(make_pair("西瓜", 1));

 }

2、OJ题：前k个高频单词

思路：

①、先创建个map对象，利用operator[ ]对其中的字符串排序（会按ASCII码排序），那么key值应该是string，因为map是按照key值从低到高排序的

②、因为出现频率高的在前，且还有重复数据的出现，故使用multimap和仿函数

把countMap中的数据插入到multimap中，multimap的key值是int类型的，那相当于multimap按出现频率排序，那出现频率高的就会在前，而出现频率相同的，之前operator[ ]已排好序了，按字典顺序排的，小的ASCII码在前

③、因为返回vector<string>，故只把multimap中的string存入到结果中即可，访问他的string即迭代器位置->second

class Solution {
public:
	vector<string> topKFrequent(vector<string>& words, int k) {
		map<string, int> countMap;
		//统计每个字符串出现了多少次
		for (auto& e : words)
		{
			countMap[e]++;//map会自动对key值排序，即对string排序，并修改对应的value值
		}
		//但我们现在需对value值排序，即对int排序,因为要找出现频率高的
		
		//法一、将pair<string, int>键值对放到vector中，用sort排序，还要写一个
		//按int比较的仿函数，因为sort是快排实现的，不稳定，排完了，还需对次数相同的按字母排,要存入vector是因为
		//sort只供支持随机访问的容器使用，如vector、deque

		//法二、用multimap按次数排序，利用仿函数控制从大到小排
		multimap<int, string,greater<int>> sortMap;//multimap可以保证数据的重复出现
		for (auto& kv : countMap)
		{
			sortMap.insert(make_pair(kv.second, kv.first));//排完序后插入到multimap,其会按int从大到小排
			//排完后
			//出现次数高的在前面，而出现次数相同的，之前已用operator[]按string排序了
		}

		vector<string> v;
		auto it = sortMap.begin();
		while (it != sortMap.end())
		{
			if (k == 0)
				break;
			v.push_back(it->second);//插入字符串
			++it;
			--k;//插入完一个就--
		}

		return v;
	}
};