【C++】STL——unordered_map和unordered_set的介绍和使用

unordered_set和unordered_map的介绍和使用

一、unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到O(logN) ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同。下面就开始依次进行讲解。

---

二、unordered_set

1.unordered_set的介绍

• 1、unordered_set是不按特定顺序存储键值的关联式容器，其允许通过键值快速的索引到对应的元素。
• 2、在unordered_set中，元素的值同时也是唯一地标识它的key。
• 3、在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的key，unordered_set将相同哈希值的键值放在相同的桶中。
• 4、unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。
• 5、它的迭代器至少是前向迭代器。(单向迭代器)

---

2.unordered_set的构造方式

• 1、构造一个空容器

unordered_set<int> s1;

• 2、拷贝构造一个容器

unordered_set<int> s2(s1);

• 3、使用迭代器构造一段区间

string str("string");
unordered_set<string> s3(str.begin(), str.end());

---

3.unordered_set的函数接口说明

成员函数	功能说明
begin	获取容器中第一个元素的正向迭代器
end	获取容器中最后一个元素下一个位置的正向迭代器
insert	插入指定元素
erase	删除指定元素
find	查找指定元素
size	获取容器中元素的个数
clear	清空容器
swap	交换两个容器中的数据
count	获取容器中指定元素值的元素个数

示例：

void test_unordered_set2()
{
	unordered_set<int> us;
	//插入元素（去重）
	us.insert(1);
	us.insert(12);
	us.insert(6);
	us.insert(23);
	us.insert(3);
	us.insert(6);
	us.insert(0);
	//遍历容器方式一（范围for）
	for (auto e : us)
	{
		cout << e << " "; // 1 12 6 23 3 0
	}
	cout << endl; 
	//删除元素方式一
	us.erase(3);
	//删除元素方式二
	unordered_set<int>::iterator pos = us.find(1); //查找值为1的元素
	if (pos != us.end())
	{
		us.erase(pos);
	}
	//遍历容器方式二（迭代器遍历）
	unordered_set<int>::iterator it = us.begin();
	while (it != us.end())
	{
		cout << *it << " "; // 12 6 23 0
		it++;
	}
	cout << endl; 
	//容器中值为2的元素个数
	cout << us.count(2) << endl; //0
	//容器大小
	cout << us.size() << endl; //4
	//清空容器
	us.clear();
	//容器判空
	cout << us.empty() << endl; //1
	//交换两个容器的数据
	unordered_set<int> tmp{1, 2, 3, 4,};
	us.swap(tmp);
	for (auto e : us)
	{
		cout << e << " ";//1 2 3 4
	}
	cout << endl; 
}

---

4.unordered_multiset的介绍及使用

unordered_multiset和unordered_set的底层都是用哈希表来实现的，所提供的成员函数和unordered_set无显著差异，唯一的区别在于unordered_multiset允许键值冗余，即key值可以是一样的，但是unordered_set不允许。对比如下：

由于unordered_multiset容器允许键值冗余，因此该容器中成员函数find和count的意义与unordered_set容器中的也有所不同：

成员函数count	功能说明
unordered_set对象	值为key的元素存在则返回1，不存在则返回0
unordered_multiset对象	返回键值为key的元素的个数

成员函数ind	功能说明
unordered_set对象	返回值为key的元素的迭代器位置
unordered_multiset对象	返回底层哈希表中的第一个值为key的元素的迭代器

---

三、unordered_map

1.unordered_map的介绍

• 1、unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
• 2、在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
• 3、在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
• 4、unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
• 5、unordered_map实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
• 6、它的迭代器至少是前向(单向)迭代器。

---

2.unordered_map的构造方式

• 1、构造一个空容器：

unordered_map<string, int> mp1;

• 2、拷贝构造一个容器：

unordered_map<string, int> mp2(mp1);

• 3、使用迭代器区间构造一个容器：

unordered_map<string, int> mp2(mp1.begin(), mp1.end());

---

3.unordered_map的函数接口说明

• 1、unordered_map的容量

函数声明	功能介绍
bool empty() const	检测是否为空
size_t size() const	获取有效元素个数

• 2、unordered_map的迭代器

函数声明	功能介绍
begin	赶回unordered_map第一个元素的迭代器位置
end	返回unordered_map最后一个元素下一个位置的迭代器
cbegin	返回unordered_map第一个元素的const迭代器
cend	返回unordered_map最后一个元素下一个位置的const迭代器

• 3、unordered_map的元素访问

函数声明	功能介绍
operator[ ]	返回与key对应的value，没有一个默认值

**注意：**针对于[ ]的重载，该函数实际调用哈希桶的插入操作，用参数key与V()构造一个默认值往底层哈希桶中插入，针对插入成功与否，有如下说明：

1. 如果key不在哈希桶中，插入成功，返回V()。
2. 若key已经在哈希桶中，插入失败，将key对应的value返回。

其实和map的[ ]运算符重载的规则没有啥区别。

• 4、unordered_map的查询

函数声明	功能介绍
iterator find(const K& key)	返回key在哈希桶中的位置
size_t count(const K& key)	返回哈希桶中关键码为key的键值对的个数

**注意：**unordered_map中key是不能重复的，因此count函数的返回值最大为1。

• 5、unordered_map的修改操作

函数声明	功能介绍
insert	向容器中插入键值对
erase	删除容器中的键值对
void clear	清空容器中的有效元素个数
void swap(unordered map&)	交换两个容器中的元素

• 6、unordered_map的桶操作

函数声明	功能介绍
size_t bucket_count() const	返回哈希桶中桶的总个数
size_t bucket_size(size_t n) const	返回n号桶中有效元素的总个数
size_t bucket(const K& key)	返回元素key所在的桶号

示例：

void test_unordered_map3()
{
	unordered_map<string, string> mp;
	/*insert插入*/
	//1：借助pair构造函数
	pair<string, string> kv("string", "字符串");
	mp.insert(kv);
	//2：借助pair构造匿名对象插入
	mp.insert(pair<string, string>("blue", "蓝色"));
	//3：调用make_pair函数模板插入
	mp.insert(make_pair("sky", "天空"));
	//4：使用[]运算符重载函数进行插入
	mp["快乐"] = "happy";
	//5：使用{}
	mp.insert({ "左边", "left"});
	/*遍历*/
	//1：迭代器遍历
	unordered_map<string, string>::iterator it = mp.begin();
	while (it != mp.end())
	{
		cout << it->first << ":" << it->second << " ";
		it++;
	}
	cout << endl; // string:字符串 blue:蓝色 sky:天空 happy:快乐 left:左边
	//2：范围for
	for (auto e : mp)
	{
		cout << e.first << ":" << e.second << " ";
	}	
	cout << endl; // string:字符串 blue:蓝色 sky:天空 happy:快乐 left:左边
	/*删除*/
	//1：根据key删除
	mp.erase("string");
	//2：根据迭代器位置删除
	unordered_map<string, string>::iterator pos = mp.find("sky");
	if (pos != mp.end())
	{
		mp.erase(pos);
	}
	for (auto e : mp)
	{
		cout << e.first << ":" << e.second << " ";
	}
	cout << endl; // blue:蓝色 happy:快乐 左边:left
	/*修改*/
	//1：通过迭代器位置修改
	pos = mp.find("快乐");
	if (pos != mp.end())
	{
		pos->second = "ikun";
	}
	//2：通过[]修改
	mp["左边"] = "小黑子";
	for (auto e : mp)
	{
		cout << e.first << ":" << e.second << " ";
	}
	cout << endl; // blue:蓝色 快乐:ikun 左边:小黑子
	/*交换*/
	unordered_map<string, string> tmp{ { "2023", "年"}, {"4", "月"}, {"3", "日"}};
	mp.swap(tmp);
	for (auto e : mp)
	{
		cout << e.first << e.second << " ";
	}
	cout << endl; //2023年4月3日
}

---

4.unordered_multimap的介绍及使用

unordered_multimap和unordered_map的底层都是用哈希表来实现的，所提供的成员函数和unordered_map无显著差异，唯一的区别在于unordered_multimap允许键值冗余，即key值可以是一样的，但是unordered_map不允许。对比如下：

unordered_multimap允许键值冗余，这也就导致其内部的find和count函数和unordered_map中的有所区别，如下：

成员函数count	功能说明
unordered_map对象	值为key的元素存在则返回1，不存在则返回0
unordered_multimap对象	返回键值为key的元素的个数

成员函数find	功能说明
unordered_map对象	返回值为key的元素的迭代器位置
unordered_multimap对象	返回底层哈希表中的第一个值为key的元素的迭代器

---

四、map/set与unordered_map/unordered_set的区别

下面将从如下几个角度进行对比：

	unordered_map / unordered_set	map / set
底层数据结构	哈希表/散列表	红黑树
是否有序	无序	有序
查找的效率	O(1)	O(logN)
迭代器类型	单向迭代器	双向迭代器
头文件	#include #include	#include < map > #include < set >

---

五、set/unordered_set的性能对比

因map与unordered_map容器的差别和set与unordered_set容器的差别类似，所以下面我们就以set和unordered_set测试为例，来测试插入、删除、查找的效率

void test_speed()
{
	const size_t N = 1000000;

	unordered_set<int> us;
	set<int> s;

	vector<int> v;
	v.reserve(N);
	srand((unsigned int)time(0));
	for (size_t i = 0; i < N; ++i)
	{
		//v.push_back(rand());
		//v.push_back(rand()+i);
		v.push_back(i);
	}

	size_t begin1 = clock();
	for (auto e : v)
	{
		s.insert(e);
	}
	size_t end1 = clock();
	cout << "set insert:" << end1 - begin1 << endl;

	size_t begin2 = clock();
	for (auto e : v)
	{
		us.insert(e);
	}
	size_t end2 = clock();
	cout << "unordered_set insert:" << end2 - begin2 << endl;


	size_t begin3 = clock();
	for (auto e : v)
	{
		s.find(e);
	}
	size_t end3 = clock();
	cout << "set find:" << end3 - begin3 << endl;

	size_t begin4 = clock();
	for (auto e : v)
	{
		us.find(e);
	}
	size_t end4 = clock();
	cout << "unordered_set find:" << end4 - begin4 << endl;

	cout << s.size() << endl;
	cout << us.size() << endl;

	size_t begin5 = clock();
	for (auto e : v)
	{
		s.erase(e);
	}
	size_t end5 = clock();
	cout << "set erase:" << end5 - begin5 << endl;

	size_t begin6 = clock();
	for (auto e : v)
	{
		us.erase(e);
	}
	size_t end6 = clock();
	cout << "unordered_set erase:" << end6 - begin6 << endl;

}

总结：当测试数据量较少时，二者差距不大，数据量较大时，用unordered_系列更优。