【C++高阶】高效数据结构的探索（map&&set）

island1314

已于 2024-07-18 17:03:32 修改

阅读量731

点赞数 45

分类专栏： C++学习—进步之路文章标签： c++ 数据结构开发语言

于 2024-07-18 17:02:46 首次发布

本文链接：https://blog.csdn.net/island1314/article/details/140525677

版权

C++学习—进步之路专栏收录该内容

22 篇文章 2 订阅

订阅专栏

✨ 人生到处知何似，应似飞鸿踏雪泥 🌏

📃个人主页：island1314

🔥个人专栏：C++学习

🚀 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

🚀前言：

【C++深度学习】二叉搜索树的全面解析与高效实现-CSDN博客

通过之前对二叉搜索树的学习，我相信大家对set和map也应该有所了解，set就类似于二叉搜索树的K模型，而map就类似于二叉搜索树的KV模型，下面就让我们进入对其的了解吧，踏上这神秘的学习之旅

1. 关联式容器

📒在初阶阶段，我们已经接触过STL中的部分容器，比如：vector、list、deque、
forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身

📙关联式容器（Associative Containers） 是C++标准模板库（STL）中的一类重要容器，主要用于存储和快速检索键值对（key-value pairs）形式的数据。这类容器与序列式容器（如vector、deque、list）的主要区别在于，关联式容器中的元素是按照特定的排序准则（通常是键的大小）进行排序的，从而允许通过键来快速查找、插入和删除元素。

关联式容器： 也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高

2. 键值对

概念： 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息，比如我们上一篇所提到的kv模型结构 存在对应关系

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)
	{}
};

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

📕根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构

树型结构的关联式容器主要有四种：map、set、multimap、multiset
共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列

📕关联式容器是C++ STL中一类重要的容器，它们通过键值对的形式存储数据，并支持快速的查找、插入和删除操作。常见的关联式容器包括set、multiset、map和multimap等，它们在不同的应用场景下提供了高效的解决方案

4. set && multiset

📜set的概念

概念： set 是 C++ 标准模板库 (STL) 中的一个关联式容器，它包含的元素是唯一的，且默认情况下元素会按照升序排序。set 的内部实现通常使用红黑树来保持其有序性和唯一性

set是按照一定次序存储元素的容器
在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的
set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们
set默认是升序，但是其内部默认不是按照大于比较，而是按照小于比较，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序
set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代

set在底层是用二叉搜索树(红黑树)实现的

📙set特征：

与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对，
set中插入元素时，只需要插入value即可，不需要构造键值对，但是set中可以存储键值对，实例化set时，将set中元素类型设置为pair即可。
set中没有重载 [] 运算符
因为set要保证其有序，因此set中元素不能被直接修改，若要修改可以先删除，再插入
set中的元素不可以重复(因此可以使用set进行去重)
使用set的迭代器遍历set中的元素，可以得到有序序列
set中的元素默认按照小于来比较

set中查找某个元素，时间复杂度为： $\log N$

set中的元素不允许修改
set中的底层使用二叉搜索树(红黑树)来实现

🎈multiset的概念

概念：multiset 是 C++ 标准库中的一个容器，它允许存储重复的元素。与 set 不同，set 中的元素是唯一的，而 multiset 中的元素可以重复

它与set唯一不同的一点就是 multiset 中的元素可以重复

简单演示一下差别:

void test3()
{
	multiset<int> s;
	s.insert(5); s.insert(5);
	s.insert(2); s.insert(2); s.insert(2);
	s.insert(1);
	s.insert(9);
	s.insert(7);

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

	int x;
	cin >> x;
	auto pos = s.find(x); //查找x时，返回中序第一个
	while (pos != s.end() && *pos == x)  
	{
		cout << *pos << " ";
		++pos;
	}
	cout << endl;

}

📒set使用

🌈set的模板参数列表

T: set中存放元素的类型，实际在底层存储<value, value>的键值对
Compare：set中元素默认按照小于来比较
Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理

void test1()
{
	set<int> s;
	s.insert(5); s.insert(5);
	s.insert(2); s.insert(2);
	s.insert(1);
	s.insert(9);
	s.insert(7);

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

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

	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	int x;
	cin >> x;

	if (s.find(x) != s.end()) cout << "存在" << endl;
	else cout << "不存在" << endl;

	auto pos1 = find(s.begin(), s.end(), x); //O(N)
	auto pos2 = s.find(x); // O(log(N))

	if (s.count(x))  //O(log(N))
		cout << "存在" << endl;
	else cout << "不存在" << endl;

	s.insert(x);
	cout << "插入：";
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "删除：";
	s.erase(s.begin(),s.end());
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

void test2()
{
	std::set<int> myset;
	std::set<int>::iterator itlow, itup;
	
	for (int i = 1; i < 10; i++) myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
	
	// [30, 60]
	// >= 30

	itlow = myset.lower_bound(24);                //
	// > 60
	itup = myset.upper_bound(34);         
	cout << *itlow << " " << *itup << endl;

	myset.erase(itlow, itup);                     // 10 20 70 80 90

	std::cout << "myset contains:";
	for (std::set<int>::iterator it = myset.begin(); it != myset.end(); ++it)
	    std::cout << ' ' << *it;
	std::cout << '\n';
}

在上面中：

在set的这些函数中，用的最多的就是insert，find，erase

🌈insert

首先insert一般是直接插入元素，或者是一段迭代器区间，在直接插入一个元素时，它的返回值是pair
当插入成功时，first返回新位置的迭代器，然后second返回true;
当set中已经存在该元素时，插入失败，first返回已有元素位置的迭代器，然后second返回false

🌈find

find不用多说，在set中是找到则返回该位置迭代器
在multiset中是返回第一个该元素位置的迭代器

🌈erase

erase在set中主要的作用就是删除该迭代器位置的元素，或者删除迭代器区间

第二种用法是针对multiset的，multiset可以有重复元素，因此可以返回删除元素的个数

🌈lower_bound 和 upper_bound

这里介绍两个没有见过的函数upper_bound，lower_bound

lower_bound：返回>=该值元素位置的迭代器
upper_bound：返回>该值元素位置的迭代器

这两个函数通常可以和erase结合使用删除一段迭代器区间

5. map 与 multimap

🎩map的概念

📚概念： map 是 C++ 标准库中的一个关联容器，它存储的元素都是键值对（key-value pairs），并且键（key）是唯一的。在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair：

typedef pair<const key, T> value_type;

🎩特点:

map中key不能修改，因为如果修改了就不能保证红黑树的特性了，即有序
map中key是唯一的，每个key都有与之对应的value，经常需要通过key获取value，因此 map为了形象简单重载了[]运算符, multimap中key是可以重复的，如果重载了[]运算符，给定一个key时，就没有办法返回 value了，因此，multimap中没有重载[]运算符

🎈multimap的概念

概念： multimap 是 C++ 标准库中的一个关联容器，它允许存储具有相同键的多个值。与 map 不同，map 中的键是唯一的，而 multimap 中的键可以重复

multimap中的接口可以参考map，功能都是类似的。

注意：

multimap中的key是可以重复的
multimap中的元素默认将key按照小于来比较
multimap中没有重载operator[]操作

🧩map的使用

void test1()   //遍历
{
	/*map<string, string> dict;
	pair<string, string> kv1("left", "左边");*/
	
	map的多种初始化方式
	//dict.insert(kv1);
	//dict.insert(pair<string, string>("right", "右边"));
	//dict.insert(make_pair("insert", "插入"));

	pair<string, string> kv2 = {"string","字符串" };
	//dict.insert({ "string", "字符串" });

	map<string, string> dict = { {"left", "左边"}, {"right", "右边"},{"insert", "插入"},{ "string", "字符串" } };

	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		//cout << (*it).first <<":"<<(*it).second << endl;
		//cout << (*it).first << ":" << (*it).second << endl;
		cout << it->first << ":" << it->second << endl;

		++it;
	}
	cout << endl;
	for (const auto& e : dict)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << endl;

	for (auto& [x, y] : dict) //C++17支持
	{
		cout << x << ":" << y << endl;
	}
	cout << endl;

	string str;
	while (cin >> str)
	{
		auto ret = dict.find(str);
		if (ret != dict.end())
		{
			cout << "->" << ret->second << endl;
		}
		else
		{
			cout << "无此单词，请重新输入" << endl;
		}
	}
}

void test3()   //插入
{
	map<string, string> dict;
	dict.insert(make_pair("sort", "排序"));
	//插入 + 修改
	dict["left"] = "左边"; 

	//修改
	dict["left"] = "左边 + 修改";

	//key不存在->插入<"insert", "">
	dict["insert"];

	//存在->查找
	cout << dict["left"] << endl;


}

🌈map的模板参数说明

key: 键值对中key的类型
T：键值对中value的类型
Compare: 比较器的类型，默认按小于比较

🌈insert

在insert插入中，所需要的元素类型是value_type - > pair

insert：插入成功 pair<新插入key所在节点的iterator， true>插入失败 pair<已经存在的key所在节点的iterator，false>

🌈map的成员类型

🌈pair

pair可以支持带参构造，无参构造和拷贝构造

map插入代码演示：

int main()
{
	map<string,string> d;
	d.insert(pair<string, string>("insert", "插入"));
	d.insert(pair<const char*, const char*>("find", "查找"));
	return 0;
}

🌈make_pair

而一般我们并不会这没写，因为有make_pair的存在，我们往往使用make_pair

make_pair是一个函数模板，他可以自己推演类型

int main()
{
	map<string,string> d;
	d.insert(make_pair("erase", "删除"));
	return 0;
}

🌈operator[ ]

map中重载了[]运算符，因为其需要通过key获取value,set没有

在使用operator[ ]时，它会自动插入一个元素，在插入成功时，返回该位置的second(默认为0)，在插入失败时，它就会返回已有位置的second。

💧map实际应用

✨计数

void test2()  //映射计数
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	int i = int(); //匿名构造, 为0
	int j = int(10);
	map<string, int> countTree; //故其second的值最初为0
	for (const auto& str : arr)
	{
		// 先查找水果在不在搜索树中
		// 1、不在，说明水果第一次出现，则插入<水果, 1>
		// 2、在，则查找到的节点中水果对应的次数++
		//BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.find(str);  
		if (ret == countTree.end())  //没有找到
		{
			countTree.insert({ str, 1 });
		}
		else
		{
			ret->second++;
		}
	}
	
	for (const auto& e : countTree)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << endl;


	map<string, int> countTree1; //第二种统计方法
	for (const auto& str : arr)
	{
		countTree1[str]++;
	}
	for (const auto& e : countTree1)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << endl;
}

📖6. 总结拓展

💧在实际中的练习与运用

这里推荐两个题目让大家练习一下，方便巩固set与map
前K个高频单词
 两个数组的交集

island1314

关注

45
点赞
踩
46

收藏

觉得还不错? 一键收藏
58
评论
【C++高阶】高效数据结构的探索（map&&set）

【C++深度学习】二叉搜索树的全面解析与高效实现-CSDN博客通过之前对二叉搜索树的学习，我相信大家对set和map也应该有所了解，set就类似于二叉搜索树的K模型，而map就类似于二叉搜索树的KV模型，下面就让我们进入对其的了解吧，踏上这神秘的学习之旅这里推荐两个题目让大家练习一下，方便巩固set与map前K个高频单词两个数组的交集%5Clog%20N。
复制链接

扫一扫

专栏目录