哈希表学习

于 2025-05-26 16:35:22 发布
阅读量37 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： 散列表 学习 数据结构
原文链接：https://blog.youkuaiyun.com/weixin_74006549/article/details/147425727?fromshare=blogdetail&sharetype=blogdetail&sharerId=147425727&sharerefer=PC&sharesource=TengYun_zhang&sharefrom=from_link
文章目录

C++STL(七) ：unordered_set、unordered_map的介绍及使用

unordered_set的介绍

  1. 唯一性
    • 类似 set，所有元素唯一（不允许重复键值）
    • 插入重复元素时，操作会被忽略（可通过返回值判断是否成功）
  2. 无序性
    • 元素顺序由哈希函数决定，遍历时无法预测顺序
    • 与 set（基于红黑树的有序容器）形成对比
  3. 哈希表实现
    • 底层通过哈希表存储元素，支持平均 O(1) 时间复杂度的插入、删除和查找操作
    • 最坏情况下（如哈希冲突严重）时间复杂度退化为 O(n)
  4. 动态调整
    • 哈希表的桶（bucket）数量会根据元素数量动态扩展/收缩，以平衡性能与内存占用

unordered_set的使用

unordered_set的定义方式
  • 方式一： 构造一个某类型的空容器
unordered_set<int> us1; //构造int类型的空容器
  • 方式二： 拷贝构造某同类型容器的复制品
unordered_set<int> us2(us1); //拷贝构造同类型容器us1的复制品
  • 方式三： 使用迭代器拷贝构造某一段内容
string str("abcedf");
unordered_set<char> us3(str.begin(), str.end()); //构造string对象某段区间的复制品

 

 
    AI写代码
    unordered_set接口的使用
    成员函数功能
    insert()插入指定元素
    erase()删除指定元素
    find()查找指定元素
    size()获取容器中元素的个数
    empty()判断容器是否为空
    clear()清空容器
    swap()交换两个容器中的数据
    count()获取容器中指定元素值的元素个数

    使用示例：

    #include <iostream>
#include <unordered_set>
using namespace std;

int main()
{
	unordered_set<int> us;
	//插入元素（去重）
	us.insert(1);
	us.insert(4);
	us.insert(3);
	us.insert(3);
	us.insert(2);
	us.insert(2);
	us.insert(3);
	//遍历容器方式一（范围for）
	for (auto e : us)
	{
		cout << e << " ";
	}
	cout << endl; //1 4 3 2
	//删除元素方式一
	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 << " ";
		it++;
	}
	cout << endl; //4 2
	//容器中值为2的元素个数
	cout << us.count(2) << endl; //1
	//容器大小
	cout << us.size() << endl; //2
	//清空容器
	us.clear();
	//容器判空
	cout << us.empty() << endl; //1
	//交换两个容器的数据
	unordered_set<int> tmp{ 11, 22, 33, 44 };
	us.swap(tmp);
	for (auto e : us)
	{
		cout << e << " ";
	}
	cout << endl; //11 22 33 44
	return 0;
}
    unordered_set的适用场景
    1. 快速查找/去重
      • 需要频繁检查元素是否存在（如缓存、黑名单过滤）
      • 数据量大时，性能优于 set（哈希表 vs 红黑树）
    2. 不依赖顺序的场景
      • 例如统计唯一单词数、记录用户ID等
    3. 避免使用的情况
      • 需要有序遍历元素时，使用 set 或 map
      • 哈希冲突频繁时，性能可能下降
    unordered_multiset

    unordered_multiset容器与unordered_set容器的底层数据结构是一样的，都是哈希表，其次，它们所提供的成员函数的接口都是基本一致的，这两种容器唯一的区别就是，unordered_multiset容器允许键值冗余，即unordered_multiset容器当中存储的元素是可以重复的

    #include <iostream>
#include <unordered_set>
using namespace std;

int main()
{
	unordered_multiset<int> ums;
	//插入元素（允许重复）
	ums.insert(1);
	ums.insert(4);
	ums.insert(3);
	ums.insert(3);
	ums.insert(2);
	ums.insert(2);
	ums.insert(3);
	for (auto e : ums)
	{
		cout << e << " ";
	}
	cout << endl; //1 4 3 3 3 2 2
	return 0;
}

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

    成员函数find功能
    unordered_set容器返回键值为val的元素的迭代器
    unordered_multiset容器返回底层哈希表中第一个找到的键值为val的元素的迭代器
    成员函数count功能
    unordered_set容器键值为val的元素存在则返回1，不存在则返回0（find成员函数可替代）
    unordered_multiset容器返回键值为val的元素个数（find成员函数不可替代）

    unordered_map的介绍

    1. 键唯一性
      • 所有键（key）唯一，重复插入同一键时会覆盖原有值
      • 类似 map，但 unordered_multimap 允许键重复
    2. 无序性
      • 元素顺序由哈希函数决定，遍历时无法预测顺序
      • 与 map（按键排序）形成对比
    3. 哈希表实现
      • 底层通过哈希表存储键值对，支持平均 O(1) 时间复杂度的插入、删除和查找操作
      • 最坏情况下（哈希冲突严重）时间复杂度退化为 O(n)
    4. 动态调整
      • 哈希表的桶（bucket）数量会根据元素数量动态扩展/收缩，优化性能与内存占用

    unordered_map的使用

    unordered_map的定义方式
    • 方式一： 指定key和value的类型构造一个空容器
    unordered_map<int, double> um1; //构造一个key为int类型，value为double类型的空容器

 
    
 
    • 1
    AI写代码
    • 方式二： 拷贝构造某同类型容器的复制品
    unordered_map<int, double> um2(um1); //拷贝构造同类型容器um1的复制品

 
    
 
    • 1
    AI写代码
    • 方式三： 使用迭代器拷贝构造某一段内容
    unordered_map<int, double> um3(um2.begin(), um2.end()); //使用迭代器拷贝构造um2容器某段区间的复制品

 
    
 
    • 1
    AI写代码
    unordered_map接口的使用
    成员函数功能
    insert插入键值对
    erase删除指定key值的键值对
    find查找指定key值的键值对
    size获取容器中元素的个数
    empty判断容器是否为空
    clear清空容器
    swap交换两个容器中的数据
    count获取容器中指定key值的元素个数

    除了上述的成员函数之外，unordered_map容器当中还实现了[ ]运算符重载函数，该重载函数的功能非常强大：[key]

    若当前容器中已有键值为key的键值对，则返回该键值对value的引用
    若当前容器中没有键值为key的键值对，则先插入键值对<key, value()>，然后再返回该键值对中value的引用

    使用示例：

    #include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main()
{
	unordered_map<int, string> um;
	//插入键值对方式一：构造匿名对象插入
	um.insert(pair<int, string>(1, "one"));
	um.insert(pair<int, string>(2, "two"));
	um.insert(pair<int, string>(3, "three"));
	//遍历方式一：范围for
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //1->one 2->two 3->three
	//插入键值对方式二：调用make_pair函数模板插入
	um.insert(make_pair(4, "four"));
	um.insert(make_pair(5, "five"));
	um.insert(make_pair(6, "six"));
	//遍历方式二：迭代器遍历
	unordered_map<int, string>::iterator it = um.begin();
	while (it != um.end())
	{
		cout << it->first << "->" << it->second << " ";
		it++;
	}
	cout << endl; //1->one 2->two 3->three 4->four 5->five 6->six
	//插入键值对方式三：利用[]运算符重载函数进行插入（常用）
	um[7] = "seven";
	um[8] = "eight";
	um[9] = "nine";
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one 2->two 3->three 4->four 5->five 6->six 7->seven 8->eight
	//删除键值对方式一：根据key值删除
	um.erase(5);
	//删除键值对方式二：根据迭代器删除
	unordered_map<int, string>::iterator pos = um.find(7); //查找键值为7的键值对
	if (pos != um.end())
	{
		um.erase(pos);
	}
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one 2->two 3->three 4->four 6->six 8->eight
	//修改键值对方式一：通过find获得迭代器，通过迭代器修改
	pos = um.find(1);
	if (pos != um.end())
	{
		pos->second = "one/first";
	}
	//修改键值对方式二：利用[]运算符重载函数进行修改（常用）
	um[2] = "two/second";
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one/first 2->two/second 3->three 4->four 6->six 8->eight
	//容器中key值为3的键值对的个数
	cout << um.count(3) << endl;
	//容器的大小
	cout << um.size() << endl;
	//清空容器
	um.clear();
	//容器判空
	cout << um.empty() << endl;
	//交换两个容器的数据
	unordered_map<int, string> tmp{ { 2021, "before" }, { 2022, "now" } };
	um.swap(tmp);
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //2021->before 2022->now
	return 0;
}

    unordered_map的适用场景
    1. 快速键值查找
      • 高频查询操作（如缓存、字典、配置项读取）
    2. 去重统计
      • 统计唯一键出现的次数或关联值
    3. 避免使用的情况
      • 需要按键顺序遍历时，使用 map
      • 哈希冲突频繁导致性能下降时，需优化哈希函数或改用 map
    unordered_multimap

    unordered_multimap容器与unordered_map容器的底层数据结构是一样的，都是哈希表，其次，它们所提供的成员函数的接口都是基本一致的，这里就不再列举了，这两种容器唯一的区别就是，unordered_multimap容器允许键值冗余，即unordered_multimap容器当中存储的键值对的key值是可以重复的

    #include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main()
{
	unordered_multimap<int, string> umm;
	//插入键值对（允许键值重复）
	umm.insert(make_pair(2022, "吃饭"));
	umm.insert(make_pair(2022, "睡觉"));
	umm.insert(make_pair(2022, "敲代码"));
	for (auto e : umm)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //2022->吃饭 2022->睡觉 2022->敲代码
	return 0;
}

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

    成员函数find功能
    unordered_map容器返回键值为key的键值对的迭代器
    unordered_multimap容器返回底层哈希表中第一个找到的键值为key的键值对的迭代器
    成员函数count功能
    unordered_map容器键值为key的键值对存在则返回1，不存在则返回0（find成员函数可替代）
    unordered_multimap容器返回键值为key的键值对的个数（find成员函数不可替代）

    其次，由于unordered_multimap容器允许键值对的键值冗余，调用[ ]运算符重载函数时，应该返回键值为key的哪一个键值对的value的引用存在歧义，因此在unordered_multimap容器当中没有实现[ ]运算符重载函数

    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值