【C++高阶六】哈希与哈希表

于 2025-08-22 18:02:24 发布
阅读量402 收藏 4
点赞数 16
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： 哈希算法 散列表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75570391/article/details/150500465

【C++高阶六】哈希与哈希表

1.什么是哈希？

理想中的搜索方法：不经过任何比较和遍历就可以直接从表中搜索想要的元素
如果构造一种存储结构，并通过某种函数能使元素的存储位置与它自身关键码之间建立映射的关系，那么在查找时只要通过函数就可以快速找到该元素

当向该结构中插入元素时，根据待插入元素的关键码，以函数计算出该元素的存储位置并按此位置进行存储
当向该结构中搜索元素时，用函数对元素的关键码进行同样的计算求得元素的存储位置，在结构中按此位置取元素比较，若关键码相等则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

2.unordered系列容器

unordered_map和unordered_set与map和set是什么关系？
在这里插入图片描述
在内部，unordered_map没有对<kye, value>按照任何特定的顺序排序

其实unordered_map和map使用起来没什么区别，那么什么时候应该用unordered系列呢？答案是你只关心键值对的内容而不关心是否有序时就选择unordered系列

3.哈希表

3.1将key与存储位置建立映射关系

3.1.1直接定址法

在这里插入图片描述

每一个值都有一个唯一位置，适用于范围比较集中的数据

3.1.2除留余数法（产生哈希冲突）

在这里插入图片描述

范围不集中，分布分散
key值跟存储位置的关系是取模出来的，不同的值有可能映射到相同的位置，造成哈希冲突，如：5和55取模后都为5

3.2解决哈希冲突的方法

3.2.1闭散列（开放定址法）

当发生哈希冲突时，如果哈希表未被装满，说明哈希表中必然还有空位置，则可以用线性探测把key存放到冲突位置中的下一个位置，若有两个取模相同的值，则将先进来的占住当前取模位置，后进来的向后探测，若有空位置则放入
在这里插入图片描述

key%len，len是表的长度

3.3.2开散列（链地址法）（哈希桶）

对关键码集合用散列函数计算散列地址，具有相同地址码归于同一个子集合，每一个子集称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头节点存储在哈希表中

在这里插入图片描述

4.实现哈希表（除留余数法建立映射）

4.1闭散列实现

4.1.1状态与结构

整体实现全部放入名为开放地址法Open_Address的命名空间中
在这里插入图片描述

假设要删除55，因为55取余后为5，所以先去位置为5的地方去找，没有找到则继续向后寻找，到空才结束
但是把33删除后，再次查找13时，由于提前遇到空，则查找直接结束，不会向后寻找 所以找到后不能直接删除，会影响继续查找

设置三种状态： 空、存在、删除

enum Status//状态
{
	EMPTY,//空
	EXIST,//存在
	DELETE//删除
};

template<class K,class V>
struct HashData
{
	pair<K, V> _kv;//kv值
	Status _status = EMPTY;//状态默认为空
};

state默认设为空，不然有可能造成映射位置没有数据，但状态为存在的情况

4.1.2 Insert

key值跟存储位置的关系是取模出来的（key%len）
len为 _tables.size() 还是 _tables.capacity()？

假设为capacity，若当前位置为空，将值填入并将状态设置为存在，就会造成越界，在vector中operator[]会做越界检查，下标是否小于size

插入：

bool Insert(const pair<K, V>& kv)
{
	size_t hashi = kv.first % _table.size();

	_table[hashi]._kv = kv;
	_table[hashi]._status = EXIST;
}

线性探测：

while (_table[hashi]._status == EXIST)
{
	hashi++;
	hashi %= _table.size();//防止越界,可以回到0
}

完整代码：

bool Insert(const pair<K, V>& kv)
{
	size_t hashi = kv.first % _table.size();
	
	while (_table[hashi]._status == EXIST)
	{
		hashi++;
		hashi %= _table.size();//防止越界,可以回到0
	}
	_table[hashi]._kv = kv;
	_table[hashi]._status = EXIST;
}

4.1.3负载因子和扩容

哈希表冲突越多效率就越低，若表中位置都满了就需要扩容，所以提出负载因子的概念
负载因子 = 填入表的元素个数 / 表的长度，用于表示 表储存数量的百分比
填入表的元素个数 越大，表示冲突的可能性越大，所以在开放定址法时，应该控制在0.7-0.8以下，超过就会扩容

if (_num * 10 / _table.size() == 7)
{
	size_t new_num = _table.size() * 2;
	HashTable<K, V> new_HT;
	for (size_t i = 0; i < _table.size();i++)//遍历旧表
	{
		if (_table[i]._status == EXIST)
		{
			new_HT.Insert(_table[i]._kv);
		}
	}
	_table.swap(new_HT._table);
}

创建new_HT，将其中的_tables的size进行扩容，通过复用insert的方式，完成对新表的映射，最后交换旧表的_tables与new_HT的_tables ，以达到更新数据的目的

4.1.4 Find

若当前位置的状态为存在或者删除，则继续找， 遇见空就结束
若在循环中找到了，则返回对应位置的地址，若没找到则返回nullptr
删除只是把要删除的数据的状态改为DELETE，但是数据本身还是在的，所以Find还是可以找到的

HashData<K, V>* Find(const K& key）
{
	size_t hashi = key % _table.size();
	while (_table[hashi]._status != EMPTY)
	{
		if (_table[hashi]._status == EXIST && _table[hashi]._kv.first == key)
		{
			return &_table[hashi];
		}
		hashi++;
		hashi %= _table.size();
	}
	return nullptr;
}

4.1.5 Erase

bool Erase(const k& key)
{
	HashData<K, V>* temp = Find(key);
	if (temp)
	{
		temp->_status = DELETE;
		_num--;
		return true;
	}
	else
	{
		return false;
	}
}

4.1.6 完整代码

using namespace std;
namespace Open_Address//闭散列（开放定址法）
{
	enum Status//状态
	{
		EMPTY,//空
		EXIST,//存在
		DELETE//删除
	};

	template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;//kv值
		Status _status = EMPTY;//状态默认为空
	};

	template<class K,class V>
	class HashTable
	{
	public:
		HashTable()
		{
			_table.resize(10);
		}

		bool Insert(const pair<K, V>& kv)
		{
			//负载因子等于0.7时扩容
			if (_num * 10 / _table.size() == 7)
			{
				size_t new_num = _table.size() * 2;
				HashTable<K, V> new_HT;
				for (size_t i = 0; i < _table.size();i++)//遍历旧表
				{
					if (_table[i]._status == EXIST)
					{
						new_HT.Insert(_table[i]._kv);
					}
				}
				_table.swap(new_HT._table);
			}

			//线性探测
			size_t hashi = kv.first % _table.size();
			while (_table[hashi]._status == EXIST)
			{
				hashi++;
				hashi %= _table.size();//防止越界,可以回到0
			}
			_table[hashi]._kv = kv;
			_table[hashi]._status = EXIST;
		}

		HashData<K, V>* Find(const K& key）
		{
			size_t hashi = key % _table.size();
			while (_table[hashi]._status != EMPTY)
			{
				if (_table[hashi]._status == EXIST && _table[hashi]._kv.first == key)
				{
					return &_table[hashi];
				}
				hashi++;
				hashi %= _table.size();
			}
			return nullptr;
		}

		bool Erase(const k& key)
		{
			HashData<K, V>* temp = Find(key);
			if (temp)
			{
				temp->_status = DELETE;
				_num--;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<HashData<K, V>> _table;//指针数组
		size_t _num;//存储的数据个数
	};
}

4.2 开散列实现

4.2.1 状态与结构

整体实现全部放入名为哈希桶Hash_Bucket的命名空间中

template<class K,class V>
struct HashNode
{
	HashNode(const pair<K,V>& kv)
		:_kv(kv)
		,_next(nullptr)
	{}

	HashNode<K, V>* _next;//指向下一个节点
	pair<K, V> _kv;//记录数据
};

4.2.2 Insert

在同一个桶中数据不分先后
在这里插入图片描述
创建一个新节点newnode，使newnode的next连接到当前映射位置，再让newnode成为桶的头节点

size_t hashi = kv.first % _table.size();
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;

4.2.3 负载因子和扩容

负载因子越大，冲突的概率越高，查找效率越低，空间利用率越高
负载因子越小，冲突的概率越低，查找效率越高，空间利用率越低

在这里插入图片描述

在这里插入图片描述
原表的节点重新计算位置后移动到新表中
由于新表的size大小为20，所以12可以找到对应位置的桶 ，而102没有对应大小的桶，所以取模来到对应2位置处，与2形成链式结构
遍历旧表中的数据，若数据为空，就往后遍历
若数据不为空，则将其移动到新表中 ，进行头插

if (_num == _table.size())
{
	size_t newsize = _table.size() == 0 ? 10 : _table.size()*2;
	vector<Node*> new_table;
	new_table.resize(newsize, nullptr);
	
	for (size_t i = 0; i < _table.size(); i++)
	{
		Node* temp = _table[i];
		while (temp)
		{
			Node* next = temp->_next;
			//挪动到新表
			size_t hashi = _table[i] % new_table.size();
			temp->_next = new_table[i];
			new_table[hashi] = temp;
			temp = next; 
		}
		_table[i] = nullptr;
	}
	_table.swap(new_table);
}

4.2.4 Find

使用temp记录当前映射位置，遍历当前位置的单链表 ，查询是否有key值的存在，若有则返回temp，若没有则返回空

Node* Find(const K& key)
{
	if (_table.size() == 0)
	{
		return nullptr;
	}

	size_t i = key % _table.size();
	Node* temp = _table[i];
	while (temp)
	{
		if (temp->_kv.first == key)
		{
			return temp;
		}
		temp = temp->_next;
	}
	return nullptr;
}

4.2.5 Erase

在这里插入图片描述
假设要删除3，则 需让表的位置指向要删除节点的下一个
在这里插入图片描述
假设要删除13，则需找到删除节点的前一个节点，使其指向要删除节点达到后一个节点

bool Erase(const K& key)
{
	size_t i = key % _table.size();
	Node* prev = nullptr;//记录前一个结点
	Node* temp = _table[i];
	while (temp)
	{
		if (temp->_kv.first == key)
		{
			if(prev == nullptr)//删除头节点
			{
				_table[i] = temp->_next;
			}
			else
			{
				prev->_next = temp->_next;
			}
			delete temp;
			return true;
		}
		prev = temp;
		temp = temp->_next;
	}
	return false;
}

4.2.6 仿函数

在这里插入图片描述
在这里插入图片描述

若为string类型，使用insert无法计算对应的hashi值，所以需要加入仿函数
在这里插入图片描述
加入全局仿函数：

template<class K>
struct HashFunc//仿函数
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>//仿函数特化
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;//乘31或者131都行，为了避免数字重复
			hash += e;
		}
		return hash;
	}
};

再次使用 HashTable时不用传入仿函数也能调用string 类型

4.2.7 完整代码

namespace Hash_Bucket//开散列（哈希桶）
{
	template<class K,class V>
	struct HashNode
	{
		HashNode(const pair<K,V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}

		HashNode<K, V>* _next;//指向下一个节点
		pair<K, V> _kv;//记录数据
	};

	template<class K,class V,class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		bool Insert(const pair<K,V>& kv)
		{
			//负载因子等于1时扩容
			Hash hash;
			if (_num == _table.size())
			{
				size_t newsize = _table.size() == 0 ? 10 : _table.size()*2;
				vector<Node*> new_table;
				new_table.resize(newsize, nullptr);
				
				for (size_t i = 0; i < _table.size(); i++)
				{
					Node* temp = _table[i];
					while (temp)
					{
						Node* next = temp->_next;
						//挪动到新表
						size_t hashi = hash(temp->_kv.first) % new_table.size();
						temp->_next = new_table[i];
						new_table[hashi] = temp;
						temp = next; 
					}
					_table[i] = nullptr;
				}
				_table.swap(new_table);
			}

			size_t hashi = hash(kv.first) % _table.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			_num++;

			return true;
		}
		Node* Find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}

			size_t i = hash(key) % _table.size();
			Node* temp = _table[i];
			while (temp)
			{
				if (temp->_kv.first == key)
				{
					return temp;
				}
				temp = temp->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			size_t i = key % _table.size();
			Node* prev = nullptr;//记录前一个结点
			Node* temp = _table[i];
			while (temp)
			{
				if (temp->_kv.first == key)
				{
					if(prev == nullptr)//删除头节点
					{
						_table[i] = temp->_next;
					}
					else
					{
						prev->_next = temp->_next;
					}
					delete temp;
					return true;
				}
				prev = temp;
				temp = temp->_next;
			}
			return false;
		}
	private:
		vector<Node*> _table;//指针数组
		size_t _num = 0;//存储的数据个数
	};
}
【C++高阶】哈希函数底层原理全面探索和深度解析
island1314的博客
07-28 1539
本文旨在揭开哈希算法的神秘面纱，带领大家深入探测哈希的底层世界。从哈希函数的内部逻辑出发，探讨其如何通过一系列的数学变换与位操作，将任意长度的输入数据映射为固定长度的输出值。同时逐步探索哈希表的数据结构冲突解决策略以及内存管理技巧。通过详细剖析哈希函数的内部逻辑与实现方式，我们将揭示那些隐藏在高效与安全背后的智慧与努力return//转成数字，把key// 特化template<>{ // 避免因为顺序不一样而产生一样的值 BKDR// 避免 abc,acb同值不同意hash *= 31。
手撕哈希表（HashTable）——C++高阶数据结构详解
qq_61500888的博客
10-02 9248
带你一命通关哈希表（散列表） 十分钟手撕数据结构原理
【C++高阶】哈希：全面剖析与深度学习
You build it, you run it
07-31 2487
详细讲解了哈希的概念和哈希函数的原理及实现
[c++高阶]哈希的深度解析
weixin_62196764的博客
11-08 1098
在顺序表和二叉树中，如果你想找一个值，那么时间复杂度是O（N）和O（logN）。这是因为在搜索的过程中经过了很多次数的比较。可以不经过任何比较，一次直接从表中得到要搜索的元素，即查找的时间复杂度为 O(1)。如果构造一种存储结构，能通过某种函数（hashFunc）使元素的存储位置与它的关键码之间能够建立一种映射的关系，那么在查找时通过该函数先找到映射值，然后通过映射值可以很快找到该元素。该方式即为哈希（散列）方法， 哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（散列表）。
【C++高阶】哈希函数底层原理探索：从算法设计到实现优化
EterNity_TiMe_的计算机学习之路
07-22 2342
在数字世界的浩瀚宇宙中，哈希算法如同星辰般璀璨，以其独特的方式照亮了数据处理与信息安全的道路。它们不仅是现代计算体系中的基石，更是连接数据安全、高效检索与分布式系统的桥梁。然而，当我们谈论哈希时，往往更多地聚焦于其上层应用与宏观效果，而忽视了支撑这些奇迹的底层机制与实现细节
【高阶数据结构】哈希表
2203_76003626的博客
12-31 1266
哈希表
C++【初识哈希】
北 海的博客
07-03 8408
哈希（Hash）是一个广泛的概念，其中包括哈希表、哈希冲突、哈希函数等诸多概念，核心为元素（键值）与存储位置（哈希值）之间的映射关系，哈希值可以通过各种哈希函数进行计算，需要尽量确保 “唯一性”，避免冲突，除此之外，哈希函数还可用于区块链中，计算 区块头（Head）中的信息，本文将带你认识哈希，学习其中的各种知识
【C++高阶】哈希之美：探索位图与布隆过滤器的应用之旅
EterNity_TiMe_的计算机学习之路
07-26 2733
在数据科学的浩瀚星空中，哈希函数犹如一颗璀璨的星辰，以其独特的光芒照亮了数据处理的每一个角落。哈希，这一简单而强大的技术，通过将任意长度的输入（如字符串、数字等）映射到固定长度的输出（即哈希值），实现了数据的快速定位与索引。然而，哈希的魅力远不止于此，当它与位图和布隆过滤器相结合时，更是催生出了一系列高效且实用的数据处理方案
【C++】初识哈希
Aron的博客
05-31 1278
哈希（Hash）是一个广泛的概念，其中包括哈希表、哈希冲突、哈希函数等，核心为元素（键值）与存储位置（哈希值）之间的映射关系，哈希值可以通过各种哈希函数进行计算，需要尽量确保 “唯一性”，避免冲突，除此之外，哈希函数还可用于区块链中，计算 区块头（Head）中的信息，本文将带你认识哈希，学习其中的各种知识。
高阶数据结构之哈希表基础讲解与模拟实现
htw250056的博客
09-12 1225
哈希表（Hash Table）是一种高效的键值对存储数据结构，广泛应用于各种需要快速查找的场景，如数据库索引、缓存系统、集合等。它的基本思想是通过哈希函数将键映射到哈希表中的一个位置，从而实现快速的数据插入、删除和查找操作。下面我们将详细介绍哈希表的工作原理、实现方式、优缺点以及应用场景。哈希表作为一种重要的数据结构，提供了高效的查找、插入和删除操作。通过设计良好的哈希函数和适当的冲突解决策略，可以最大化哈希表的性能。
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
【高阶数据结构】手撕哈希表（万字详解）
2401_84185182的博客
04-27 996
map和set遍历是有序的，unordered map/set遍历是无序的！（讲到底层就了解了）map和set是双向迭代器，系列是单向迭代器基于上面的区别相比而言，map和set更强大，为什么还需要提供unordered系列？unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log2Nlog_2 Nlog2​N)
C++进阶：哈希
QinMou
10-21 914
哈希(hash)⼜称散列，是⼀种组织数据的⽅式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建⽴⼀个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进⾏快速查找。
C++ 函数全面教程
2501_90255623的博客
08-19 392
本文全面介绍了C++函数的核心概念与使用方法。主要内容包括：函数定义与声明、参数传递方式（值/引用/指针）、默认参数与函数重载、返回类型处理（基本/引用/结构体）、特殊函数类型（内联/递归/Lambda）、函数指针等基础内容。同时涵盖现代C++特性如自动返回类型、constexpr函数和noexcept规范。文中提供了大量示例代码，并给出了函数设计的最佳实践建议，如单一职责原则、合理命名等。最后通过一个综合示例展示了如何在实际编程中应用这些概念。
C++高频知识点（三十一）
Atticus的博客
08-20 267
本文摘要了5个技术问题： 在1GB物理内存中malloc 2GB可能成功，因现代系统支持虚拟内存； 同名同参函数可通过const重载，编译器能区分const和非const版本； GET与POST区别：GET参数在URL可见有长度限制，POST通过请求体传输更安全； Redis持久化机制：RDB快照恢复快但可能丢数据，AOF日志更安全但文件较大，推荐混合模式； ++i返回自增后引用（高效），i++返回原值副本（需临时对象）。 （字数：149）
CH582、CH592、CH584硬件IIC驱动 OLED显示屏
最新发布
weald2000的专栏
08-21 654
本文介绍了IIC串行通信协议及其在OLED驱动中的应用。IIC协议采用双线制（SDA/SCL），支持多设备连接，适用于低速外设通信。文章详细说明了IIC总线拓扑设计、地址冲突处理等硬件连接要点，并提供了CH592 MCU的IIC接口配置方法。重点阐述了4Pin IIC驱动OLED屏幕的实现过程，包括SSD1315/SSD1306芯片的地址差异、数据格式和控制字节解析。通过实例代码展示了OLED初始化、像素设置、显示刷新等操作，并提供了常见问题排查指南
c++最长上升子序列长度
2402_87646581的博客
08-18 520
/bs函数：用来搜索endss数组中比arr[i]小(不能相等)的第一个元素下标（从右往左算的话）//bs就是要找6的下标（大小最接近 arr[i]且比 arr[i] 小）int len=0;//len为end数组的实际大小，也是答案所在。//dp[i]:以位置i为结尾的最长递增子序列的长度。//end[i]:长度为i+1子序列的最小结尾。//方法2：时间复杂度O（N*log N）//方法1：（时间复杂度 O（N^2））//举个例子：现在arr[i]==7。//下标 0 1 2 len。
【C语言16天强化训练】从基础入门到进阶：Day 5
2401_89899187的博客
08-21 1028
我们发现，原本我们只是单纯地统计“1”的数量，没有。
嵌入式 C++ 语言编程规范文档个人学习版（参考《Google C++ 编码规范中文版》）
C++，Java，Python，C#编程选手，偶尔刷刷leetcode
08-18 672
本文基于Google C++编码规范，针对嵌入式系统（如MCU、RTOS等）的特殊需求，提出了适配的C++编程规范。主要内容包括：1）头文件管理规范，强调防止多重包含和减少依赖；2）作用域管理，建议使用命名空间避免污染；3）类和结构体设计原则，注重构造/析构安全和拷贝控制；4）智能指针使用限制，推荐scoped_ptr而非shared_ptr；5）命名约定，要求采用描述性命名；6）代码注释规范，特别强调硬件相关说明；7）代码格式标准，统一缩进和排版；8）嵌入式特有规范，如寄存器操作、ISR设计、内存管理等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值