C++标准模板库STL---map、set容器

●🧑个人主页:你帅你先说.
●📃欢迎点赞👍关注💡收藏💖
●📖既选择了远方，便只顾风雨兼程。
●🤟欢迎大家有问题随时私信我！
●🧐版权：本文由[你帅你先说.]原创，优快云首发，侵权必究。

1.关联式容器

在之前我们已经接触过STL中的部分容器，比如：vector、list、queue等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。

2.set/multiset容器

1. set是按照一定次序存储元素的容器
2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
5. set在底层是用二叉搜索树(红黑树)实现的。

#include <set>
using namespace std;
int main()
{
	// 排序 + 去重
	set<int> s;
	s.insert(3);
	s.insert(1);
	s.insert(5);
	s.insert(2);
	s.insert(8);
	s.insert(1);
	s.insert(8);
	//迭代器遍历容器
	auto it = s.begin();

	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	//查找
	set<int>::iterator pos = s.find(30);
	//删除
	if (pos != s.end())
	{
		// pos必须一个有效位置的迭代器
		s.erase(pos);
	}

	cout << s.erase(30) << endl;
	cout << s.erase(3) << endl;

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

注意:

1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列。
5. set中的元素默认按照小于来比较。
6. set中查找某个元素，时间复杂度为:$lo{g}_{2}n$。
7. set中的元素不允许修改。(修改了数据会破坏搜索树的结构，导致搜索树不能快速的查找数据)

STL里还提供了一个multiset，和set的区别在于multiset可以存储冗余的数据。

#include <set>
using namespace std;
int main()
{
	// 排序，此时允许数据冗余，没有去重效果
	multiset<int> s;
	s.insert(3);
	s.insert(1);
	s.insert(5);
	s.insert(2);
	s.insert(8);
	s.insert(1);
	s.insert(8);
	//迭代器遍历容器
	auto it = s.begin();

	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	//因为允许数据冗余，查找就会有多种结果，find的查找结果返回的是中序遍历中第一个结点的迭代器
	pos = s.find(1);
	//注意迭代器失效问题
	//因为相同的数在中序遍历中是紧挨着的，所以用&&
	while (pos != s.end() && *pos == 1)
	{
		auto next = pos;
		++next;

		s.erase(pos);
		//erase的返回值不是简单的0和1，而是返回被删除的个数
		pos = next;
	}
	
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

3.map/multimap容器

1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:typedef pair value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的。
4. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
5. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
6. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树
7. map的key值不能修改，value可以修改。

#include <map>
using namespace std;
int main()
{
	//用map来定义中英字典
	map<string, string> dict;
	pair<string, string> kv1("sort", "排序");
	dict.insert(kv1);
	//通过pair构造键值对
	dict.insert(pair<string, string>("string", "字符串"));
	//通过make_pair构造键值对,make_pair相较于pair的优势是它可以自动推导类型
	dict.insert(make_pair("test", "测试")); 
	
	auto it = dict.begin();
	while (it != dict.end())
	{

		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;

	for (auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;
}

在STL的map中，我们发现它提供了一个对[]进行重载的接口，这个接口是随机访问的吗？显然不是。
我们来看一个案例。

#include <map>
using namespace std;
int main()
{
	//统计水果出现的次数
	string arr[] = { "苹果", "苹果", "香蕉", "苹果", "香蕉", "苹果", "樱桃" };
	map<string, int> countMap;
	for (auto& str : arr)
	{
		countMap[str]++;
	}
	for (auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;
}

那[]的底层实现是什么样的呢？
官方文档里给出的解释是这样的

(*((this->insert(make_pair(k,mapped_type()))).first)).second

我们从里向外一步步解剖
make_pair(k,mapped_type())这一步就是构造一个键值对
(this->insert(make_pair(k,mapped_type())))这个就是个insert的返回值

返回的是一个键值对，第一个参数为迭代器，第二个为bool类型。
*((this->insert(make_pair(k,mapped_type()))).first)这边就是取第一个参数即它的迭代器进行解引用
(*((this->insert(make_pair(k,mapped_type()))).first)).second取第一个迭代器的第二个参数，对应于刚刚的场景这个second就是int类型的那个变量，然后对它进行++操作，从而实现了统计。
我们从刚刚那个场景再来看看这段代码具体是怎么实现的，第一次进这个函数进行插入，假设插入苹果，make_pair构造键值对，mapped_type实际上就是对value的typedef，在这里就是int，调用int的构造函数，默认为0，插入成功，最终返回mapped_type的引用。第二个进这个函数进行插入，此时插入的还是苹果，插入失败，insetr返回插入失败这个位置的迭代器，对这个迭代器的second进行引用返回。
这个函数实际上可以写的很简洁一点

mapped_type& operator[](const key_type& k)
{
	pair<iterator,bool> ret = insetr(make_pair(k,mapped_type)));
	return ret.first->second;
}

来看一道题
本公司现在要给公司员工发波福利，在员工工作时间会提供大量的水果供员工补充营养。由于水果种类比较多，但是却又不知道哪种水果比较受欢迎，然后公司就让每个员工报告了自己最爱吃的k种水果，并且告知已经将所有员工喜欢吃的水果存储于一个数组中。然后让我们统计出所有水果出现的次数，并且求出大家最喜欢吃的前k种水果。

void GetFavoriteFruit(const vector& fruits, size_t k) 
{
	map<string, int> countMap;
	for(auto& str : fruits)
	{
		countMap[str]++;
	}
 	multimap <int, string,greater<int>> sortMap;
 	for(auto& kv:countMap)
 	{
 		sortMap.insert(make_pair(kv.second, kv.first));
 	}
 	int i = 0;
 	for(auto& kv:countMap)
 	{
 		cout << kv->second <<":" << kv->first << endl;
 		i++;
 		if(i == k)
 			break;
 	}
}

4.map/set底层结构

前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：
其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

为了处理单支树的情况，就有了AVL树，请期待下一篇有关AVL树的介绍。

喜欢这篇文章的可以给个一键三连点赞👍关注💡收藏💖