C++中map和set的介绍和应用总结

最新推荐文章于 2024-08-06 10:22:43 发布

c code

最新推荐文章于 2024-08-06 10:22:43 发布

阅读量710

点赞数 34

文章标签： c++ 开发语言数据结构 leetcode

本文链接：https://blog.csdn.net/kk6kk/article/details/138442899

版权

1、关联式容器

在STL中，有部分容器比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。
那什么是关联式容器？它与序列式容器有什么区别？
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。
总结：
序列式容器：单纯的存储数据，存储的数据和数据之间没有什么关联。
关联式容器：不仅仅是存储数据，一般还可以查找数据，存储的数据和数据之间很强关联性。

2、键值对

键值对用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。
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)
	{}
};

https://cplusplus.com/reference/utility/pair/ --pair的文档链接

3、树形结构的关联式容器

根据应用场景的不同，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。
树型结构的关联式容器主要有四种：map、set、multimap、multiset。
这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列。

3.1 set

3.1.1 set的介绍

set文档介绍链接： https://cplusplus.com/reference/set/set/?kw=set

大致内容：
1. set是按照一定次序存储元素的容器
2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
5. set在底层是用二叉搜索树(红黑树)实现的。
注意：
1. 与map / multimap不同，map / multimap中存储的是真正的键值对<key, value>，
set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列。
5. set中的元素默认按照小于来比较。
6. set中查找某个元素，时间复杂度为：O(logN)。
7. set中的元素不允许修改。
8. set中的底层使用二叉搜索树(红黑树)来实现。

3.1.2 set的使用举例

#include<set>
#include<vector>

void TestSet()
{
	//K模型搜索
	std::set<int> s1;

	//排序 + 去重
	s1.insert(1);
	s1.insert(11);
	s1.insert(3);
	s1.insert(1);
	s1.insert(2);
	s1.insert(4);

	std::set<int>::iterator it1 = s1.begin();
	while (it1 != s1.end())
	{
		//*it1 = 1; //set 不允许修改，尽管这是普通迭代器
		std::cout << *it1 << " ";
		++it1;
	}
	std::cout << std::endl;

	std::vector<int> v2 = { 1,2,3,4,5,2,343,5,3,2,34 };
	std::set<int> s2(v2.begin(), v2.end()); //一段迭代区间构造
	for (auto& x : s2) //支持迭代器就支持范围for
	{
		std::cout << x << " ";
	}
	std::cout << std::endl;

	std::set<int> s3 = { 12,23,4,1,41,5,135,3,62,6,24,62 }; //还支持这样构造，这得益于 C++11 有了 initializer_list<value_type> i1 的构造
	for (auto& x : s3) //支持迭代器就支持范围for
	{
		std::cout << x << " ";
	}
	std::cout << std::endl;

	s3.erase(135);
	for (auto& x : s3) //支持迭代器就支持范围for
	{
		std::cout << x << " ";
	}
	std::cout << std::endl;

	//查找 + 删除
	std::set<int>::iterator pos = s3.find(62); //找不到返回 end()
	if (pos != s3.end())
	{
		std::cout << *pos << std::endl;
		s3.erase(pos); //注意：这里给的迭代器要是有效的，无效的会报错，不像上面给值那种，给的值在不在都没关系。
	}
	else
	{
		std::cout << "找不到" << std::endl;
	}
	for (auto& x : s3) //支持迭代器就支持范围for
	{
		std::cout << x << " ";
	}
	std::cout << std::endl;
}

3.2 map

3.2.1 map的介绍

map文档介绍链接： https://cplusplus.com/reference/map/map/?kw=map

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

3.2.2 map的使用举例

#include<map>
#include<string>
void TestMap()
{
	std::map<std::string, std::string> dict;
	
	std::pair<std::string, std::string> kv1("sort", "排序");
	dict.insert(kv1); //可以插入一个pair类型 //这是有名对象调用构造
	dict.insert(std::pair<std::string, std::string>("erase", "删除")); //可以用匿名对象 //这是匿名对象调用构造
	dict.insert(std::make_pair("modify", "修改")); //make_pair 是一个函数模板，它可以帮你构造一个pair类型然后返回(具体细节看文档，它是在pair里面的)
												   //这个本质还是匿名对象调用构造
	dict.insert({ "string","字符串" }); //可以这样插入 //这是隐式类型转换，注意这跟initializer_list(这个一般出现在构造)没关系！！
	
	std::map<std::string, std::string> dict2 = { { "array","数组" }, { "list","链表" } }; //这才是initializer_list(这里是多重的initializer_list)

	std::map<std::string, std::string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		//std::cout << *it << " "; //这里的 *it 得到的直接是一个pair，pair不支持 << //pair里面有两个值，你直接这样打印也不好确认你是要打印哪个值
		std::cout << (*it).first << "：" << (*it).second << std::endl; //所以应该这样写
		std::cout << it->first << "：" << it->second << std::endl; //还能这样写，就像链表那里实现迭代器的时候，所重载的 -> 的操作，这样写更方便
		std::cout << it.operator->()->first << "：" << it.operator->()->second << std::endl; //上面那句代码写全就是这样的

		//it->first = "kk"; //注意：first(key)不能修改
		it->second = "kk"; //但是：second(value)可以被修改
		//注：如果是 const_iterator，则两者都不能被修改

		++it;
	}
	std::cout << std::endl;

	for (auto& kv : dict) //这里要记得是有引用，不然深拷贝的代价太大了
	{
		std::cout << kv.first << "：" << kv.second << std::endl; //注：这里用不了 ->，因为这里的 kv 相当于 (*it)

		//补充：C++17才支持的一种写法
		//auto [x, y] = kv; //这里也可以加引用： auto& [x,y] = kv;
		//有了上面这个，范围for就可以这样写了
		/*for (auto& [x, y] : dict)
		{
			std::cout << x << "：" << y << std::endl;
		}*/
		//注：该编译器目前环境只支持到 C++14，想用上面的那种写法，需要先自己调一下这个编译器的属性。
		//注：这个写法本质是没变的，但形式上变得很 Python化 了。 
	}
	std::cout << std::endl;

	//注意：map 和 set 的迭代器跟链表那里的迭代器底层是差不多，就是链表迭代器的 plus pro 版，所以 map 和 set 的 insert 不会导致迭代器失效，但是 erase 会导致迭代器失效。

	//举个栗子展示 map 最核心的部分
	std::string arr[] = { "kk","ll","cc","zz","kk","kk","ll","cc","ll","ll","ll","ll","ll","cc","kk","kk","zz" };
	std::map<std::string, int> countmap;
	for (auto& s : arr)
	{
		++countmap[s]; //这一句代码的效果，跟下面那一堆代码的效果一样。
					   //[] 里的参数是 key
					   //map 的 [] 的返回值是 value
					   //注意：map 的 [] 的底层不是 find
					   //而是相当于这段代码：V& operator[](const K& key) 
					   //					{ 
					   //						//return (*( ( this->insert(make_pair( k,mapped_type())) ).first)).second; 
					   //						//这句代码展开一下就是：					
					   //						pair<iterator,bool> ret = this->insert(make_pair(key,V()));
					   //						iterator it = ret.first; //ret 是 pair<iterator,bool> 类型的，
					   //												   它的第一个成员是 一个迭代器，该迭代器是 key 所在结点的迭代器
					   //												   它的第二个成员是 一个bool值，代表的插入成功，还是插入失败
					   //						return it->second;
					   //					}
		//通过了解了 [] 的底层之后，可以发现 [] 还有以下功能。
		//1、相当于 插入 的功能 (一般不会用这个功能来代替 insert )
		std::map<std::string, std::string> dict3;
		dict3.insert({ "string","字符串" });
		dict3["right"];
		//2、相当于 修改 的功能
		dict3["right"] = "右边";
		//3、相当于 插入 + 修改 的功能
		dict3["left"] = "左边";
		//4、相当于 查找 的功能
		std::cout << dict3["string"] << std::endl;
		//注意：虽然这个 [] 的功能众多，但 map 不能用来代替 vector，它们的很多操作即使类似，但是其代表的意义也差的非常多。

		//auto it = countmap.find(s);
		//if (it != countmap.end())
		//{
		//	++it->second;
		//}
		//else
		//{
		//	//const std::pair<std::string, int> kv = { s,1 };
		//	//countmap.insert(kv);
		//	countmap.insert({ s,1 });
		//}
	}

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

	//上面的“水果” 的排序能不能按照其出现的次数来排一下呢？
	//答：这样写就行
	//std::map<int, std::string> sortmap;
	std::multimap<int, std::string> sortmap;
	for (auto& kv : countmap)
	{
		//sortmap[kv.second] = kv.first; //颠倒一下就行了
		sortmap.insert({ kv.second,kv.first }); //这里如果用的 insert 的话，下面出现的问题的原因就变成了是：被去重了
	}

	for (auto& kv : sortmap)
	{
		std::cout << kv.first << "：" << kv.second << std::endl;
	}
	std::cout << std::endl;
	//但是这时候会出现一个问题，那就是如果有多个数据出现的次数是一样的话，那么最后就只会留下一份数据。(因为被修改了)
	//解决方法：用 multimap 就好了，但要注意，multimap 可没有 []
}

补充一道题目： https://leetcode.cn/problems/copy-list-with-random-pointer/description/

这道题可以用来练习练习怎么使用map。

本题代码：

class SolutionList {
public:
	Node* copyRandomList(Node* head) {
		//核心思路就是要建立出 拷贝链表 和 原链表 各个结点之间的关系
		//所以，可以利用 map

		//第一步，先建立好关系并将val拷贝
		std::map<Node*, Node*> CopyNodeMap;
		Node* copyhead = nullptr, * copytail = nullptr;
		Node* cur = head;
		while (cur)
		{
			if (copytail == nullptr)
			{
				copyhead = copytail = new Node(cur->val);
			}
			else
			{
				copytail->next = new Node(cur->val);
				copytail = copytail->next; //注意，这句代码要放在这里，不能放到外面去，不然下面建立的关系会不对应
			}
			CopyNodeMap[cur] = copytail; //建立关系

			cur = cur->next;
		}

		//第二步，处理random
		Node* copy = copyhead;
		cur = head;
		while (cur)
		{
			if (cur->random == nullptr) //这里需要特殊处理一下，因为map里没有存null
			{
				copy->random = nullptr;
			}
			else
			{
				copy->random = CopyNodeMap[cur->random]; //核心
			}
			copy = copy->next;
			cur = cur->next;
		}

		return copyhead;
	}
};

本题总结：map 有个很强的地方在于，它能将两个毫无联系的东西联系起来。

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

本文到此就结束了，感谢您的阅读，谢谢。

c code

关注

34
点赞
踩
15

收藏

觉得还不错? 一键收藏
2
评论
C++中map和set的介绍和应用总结

set文档介绍链接：kw=set大致内容：1. set是按照一定次序存储元素的容器2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
复制链接

扫一扫