【 C++ 】闭散列哈希表的模拟实现

最新推荐文章于 2024-05-13 09:55:25 发布
最新推荐文章于 2024-05-13 09:55:25 发布
阅读量1.5k 收藏 43
点赞数 40
分类专栏： C++ 文章标签： c++ 散列表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JX_BC/article/details/136080311
版权

哈希节点状态

我们都很清楚数组里的每一个值无非三种状态：

  1. 如果某下标没有值，则代表空EMPTY。
  2. 如果有值在代表存在EXIST。
  3. 如果此位置的值被删掉了，则表示为DELETE。

而这三种状态我们可以借助enum枚举来帮助我们表示数组里每个位置的状态。这里我们专门封装一个类来记录每个位置的状态，以此汇报给后续的哈希表。

enum State
{
	EMPTY,
	EXIST,
	DELETE
};

//哈希节点
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;//记录每个位置的状态，默认给空
};

//哈希表
template<class K, class V, class HashFunc = DefaultHash<K>>//添加仿函数便于把其他类型的数据转换为整型数据
class HashTable
{
	typedef HashData<K, V> Data;
public:
	//相关功能的实现……
private:
	vector<Data> _tables;
	size_t _n = 0;//记录存放的有效数据的个数
};

实现好了哈希节点的类，就能够很好的帮助我们后续的查找，示例：

在这里插入图片描述

  • 查找50：

50%10=0，下标0的值不是50，继续++下标往后查找，直至下标3的下标为止。

  • 查找60：

60%10=0，下标0不是，往后++下标继续查找，找到下标4发现状态为EMPTY空，此时停止查询，因为往后就不可能出现了

  • 删除10，再查找50：

50%10=0，下标0的值不是，++下标到下标1，发现状态为DELETE删除，继续++下标直至下标3的值为50，找到了。

哈希表的扩容

  • 散列表的载荷因子定义为：α = 填入表中的元素个数 / 散列表的长度。
  • α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以α越大，表明填入表中的元素越多，产生冲突的可能性就越大；反之，α越小，表明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子α的函数，只是不同处理冲突的方法有不同的函数。
  • 对于开放定址法（闭散列），载荷因子是特别重要因素，应严格限制在0.7 ~ 0.8以下。超过0.8，查表时的CPU缓存不命中（cache missing）按照质数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了载荷因子为0.75，超过此值将resize散列表。

综上，我们在后续的插入操作中，必然要考虑到扩容的情况，我们直接把负载因子控制在0.7，超过了就扩容。具体操作见下文哈希表的插入操作。

构建仿函数把所有数据类型转换为整型并特化

在我们后续的插入操作中，插入的数据类型如果是整数，那么可以直接建立映射关系，可若是字符串，就没那么容易了，因此，我们需要套一层仿函数，来帮助我们把字符串类型转换成整型的数据再建立映射关系。主要分为以下三类需要写仿函数的情况：

  1. key为整型，为默认仿函数的情况。
    此时的数据类型为整型，直接强转size_t随后返回。

  2. key为字符串，单独写个字符串转整型的仿函数。
    针对于字符串转整型，我们推出下面两种方法，不过都是会存在问题的：

    • 只用首字母的ascii码来映射，此法不合理，因为"abc"和"axy"本是俩不用字符串，经过转换，会引发冲突。
    • 字符串内所有字符ASCII码值之和，此法也会产生冲突，因为"abcd"和"bcad"在此情况就会冲突。

为了避免冲突，几位大佬推出多种算法思想，下面我取其中一种算法思想来讲解：

BKDR哈希算法：
hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..

为了能够让我们的哈希表能够自动识别传入数据的类型，不用手动声明，这里我们可以借助特化来解决，仿函数+特化总代码如下：

//利用仿函数将数据类型转换为整型
template<class K>
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
//模板的特化
template<>
struct DefaultHash<string>
{
	size_t operator()(const string& key)
	{
		//BKDR哈希算法
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii码值累计加起来
		}
		return hash;
	}
};

哈希表的插入

哈希表的插入主要是三大步骤：

  • 去除冗余
  • 扩容操作
  • 插入操作

下面分开来演示。

1、去除冗余：

  1. 复用Find查找函数，去帮助我们查找插入的值是否存在 。
  2. 若存在，直接返回false 。
  3. 不存在，再进行后续的插入操作。

2、扩容操作：

  1. 如果哈希表一开始就为空，则要扩容。
  2. 如果填入表中的元素个数*10 再 / 表的大小>=7，就扩容（*10是为了避免出现size_t的类型相除不会有小数的情况）。
  3. 扩容以后要重新建立映射关系。
  4. 创建一个新的哈希对象，扩容到先前旧表扩容的大小。
  5. 遍历旧表，把旧表每个存在的元素插入到新表，此步骤让新表自动完成映射关系，无序手动构建。
  6. 利用swap函数把新表交换到旧表那，此时的旧表就是已经扩好容且建立号映射关系的哈希表。

3、插入操作：

  1. 借助仿函数把插入的数据类型转为整型并定义变量保存插入键值对的key。
  2. 用此变量%=哈希表的size()，不能是capacity()，因为[ ]运算符会判断下标是否小于size，且对于哈希表，应该尽量控制size和capacity一样大。
  3. 遍历进行线性探测 / 二次探测，如果这个位置的状态为EXIST存在，说明还要往后遍历查找。
  4. 遍历结束，说明此位置的状态为空EMPTY或删除DELETE，可以放值。
  5. 把插入的值放进该位置，更新状态为EXIST，有效数据个数++。
//插入
bool Insert(const pair<K, V>& kv)
{
	//1、去除冗余
	if (Find(kv.first))
	{
		//说明此值已经有了，直接返回false
		return false;
	}
	//2、扩容
		//负载因子超过0.7，就扩容
	if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
	{
		size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
		//扩容以后，需要重新建立映射关系
		HashTable<K, V, HashFunc> newHT;
		newHT._tables.resize(newSize);
		//遍历旧表，把旧表每个存在的元素插入newHT
		for (auto& e : _tables)
		{
			if (e._state == EXIST)
			{
				newHT.Insert(e._kv);
			}
		}
		newHT._tables.swap(_tables);//建立映射关系后交换
	}
	//3、插入
	HashFunc hf;
	size_t starti = hf(kv.first);//取出键值对的key，并且避免了负数的情况，借用仿函数确保是整型数据
	starti %= _tables.size();
	size_t hashi = starti;
	size_t i = 1;
	//线性探测/二次探测
	while (_tables[hashi]._state == EXIST)
	{
		hashi = starti + i;//二次探测改为 +i^2
		++i;
		hashi %= _tables.size();//防止hashi超出数组
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	_n++;
	return true;
}

哈希表的查找

查找的核心逻辑就是找到key相同，就返回此对象的地址，找到空就返回nullptr，具体细分规则如下：

  1. 先去判断表的大小是否为0，为0直接返回nullptr。
  2. 按照线性探测 / 二次探测的方式去遍历，遍历的条件是此位置的状态不为空EMPTY。
  3. 如果遍历到某哈希表中的对象的值等于要查找的值（前提是此位置的状态不为DELETE删除），返回此对象的地址。
  4. 当遍历结束后，说明此位置的状态为空EMPTY，哈希表没有我们要查找的值，返回nullptr。
//查找
Data* Find(const K& key)
{
	//判断表的size是否为0
	if (_tables.size() == 0)
	{
		return nullptr;
	}
	HashFunc hf;
	size_t starti = hf(key);//通过仿函数把其它类型数据转为整型数据
	starti %= _tables.size();
	size_t hashi = starti;
	size_t i = 1;
	//线性探测/二次探测
	while (_tables[hashi]._state != EMPTY)//不为空就继续
	{
		if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
		{
			return &_tables[hashi];//找到了就返回此对象的地址
		}
		hashi = starti + i;//二次探测改为 +i^2
		++i;
		hashi %= _tables.size();//防止hashi超出数组
	}
	return nullptr;
}

哈希表的删除

删除的逻辑很简单，遵循下面的规则：

  1. 复用Find函数去帮我们查找删除的位置是否存在。
  2. 若存在，把此位置的状态置为DELETE即可，此时表中的有效数据个数_n需要减减，最后返回true。
  3. 若不存在，直接返回false。
//删除
bool Erase(const K& key)
{
	//复用Find函数去帮助我们查找删除的值是否存在
	Data* ret = Find(key);
	if (ret)
	{
		//若存在，直接把此位置的状态置为DELETE即可
		ret->_state = DELETE;
		return true;
	}
	else
	{
		return false;
	}
}

完整代码

#pragma once
#include<iostream>
#include<string>
#include<vector>
using namespace std;

//利用仿函数将数据类型转换为整型
template<class K>
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
//模板的特化
template<>
struct DefaultHash<string>
{
	size_t operator()(const string& key)
	{
		//BKDR哈希算法
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii码值累计加起来
		}
		return hash;
	}
};

//闭散列哈希表的模拟实现
namespace CloseHash
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};
	//哈希节点状态的类
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;//记录每个位置的状态，默认给空
	};


	//哈希表的类
	template<class K, class V, class HashFunc = DefaultHash<K>>//添加仿函数便于把其他类型的数据转换为整型数据
	class HashTable
	{
		typedef HashData<K, V> Data;
	public:
		//插入
		bool Insert(const pair<K, V>& kv)
		{
			//1、去除冗余
			if (Find(kv.first))
			{
				//说明此值已经有了，直接返回false
				return false;
			}
			//2、扩容
				//负载因子超过0.7，就扩容
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				//扩容以后，需要重新建立映射关系
				HashTable<K, V, HashFunc> newHT;
				newHT._tables.resize(newSize);
				//遍历旧表，把旧表每个存在的元素插入newHT
				for (auto& e : _tables)
				{
					if (e._state == EXIST)
					{
						newHT.Insert(e._kv);
					}
				}
				newHT._tables.swap(_tables);//建立映射关系后交换
			}
			//3、插入
			HashFunc hf;
			size_t starti = hf(kv.first);//取出键值对的key，并且避免了负数的情况，借用仿函数确保是整型数据
			starti %= _tables.size();
			size_t hashi = starti;
			size_t i = 1;
			//线性探测/二次探测
			while (_tables[hashi]._state == EXIST)
			{
				hashi = starti + i;//二次探测改为 +i^2
				++i;
				hashi %= _tables.size();//防止hashi超出数组
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			_n++;
			return true;
		}
		//查找
		Data* Find(const K& key)
		{
			//判断表的size是否为0
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t starti = hf(key);//通过仿函数把其它类型数据转为整型数据
			starti %= _tables.size();
			size_t hashi = starti;
			size_t i = 1;
			//线性探测/二次探测
			while (_tables[hashi]._state != EMPTY)//不为空就继续
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];//找到了就返回此对象的地址
				}
				hashi = starti + i;//二次探测改为 +i^2
				++i;
				hashi %= _tables.size();//防止hashi超出数组
			}
			return nullptr;
		}
		//删除
		bool Erase(const K& key)
		{
			//复用Find函数去帮助我们查找删除的值是否存在
			Data* ret = Find(key);
			if (ret)
			{
				//若存在，直接把此位置的状态置为DELETE即可
				ret->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<Data> _tables;
		size_t _n = 0;//记录存放的有效数据的个数
	};
}
.滄海难为水
关注
  • 40
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表开散列哈希桶实现
01-07
开散列法对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成 一个向量，因此，向量的元素个数与可能的...
【C++】哈希表模拟实现
m0_69442905的博客
10-10 979
了解哈希表的几种实现方式，初步了解哈希函数，初步构建简单的封闭哈希表，实现插入，查找，删除等。然后对封闭哈希表基础上进行更新，引出介绍链式哈希表，实现最简单的插入查找，删除
C++--哈希表--开散列（哈希桶的模拟实现）--1110
qq_68741368的博客
11-11 356
手把手教你模拟开散列的哈希表
C++哈希表的实现
Wzs040810的博客
12-23 5289
C++哈希表的实现
【C++】开散列哈希表封装实现unordered_map和unordered_set
The porters of knowledge
04-05 810
unordered系列关联式容器，哈希冲突和哈希函数，闭散列和开散列哈希表的实现，用闭散列哈希表封装实现unordered_set和map，封装实现时哈希表特殊的const迭代器……
C++模拟实现哈希表
m0_53005929的博客
05-22 2165
C++模拟实现哈希表
C++实现哈希表。
TPON的博客
11-17 6307
C++模拟实现哈希表
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7105
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
【 C++ 】哈希表底层结构剖析
bit_zyx的博客
09-24 1687
目录 1、unordered系列底层结构 2、哈希概念 3、哈希冲突 4、哈希函数（直接定址 + 除留余数） 5、哈希冲突解决 闭散列（线性探测 + 二次探测） 开散列
【C++】手撕哈希表的闭散列和开散列
AAlykk的博客
03-24 1335
谈到哈希表，大家都做过这样的题目，统计字符串的字母个数，像这样的题目可以创建一个数组，每个字母采用 a['ch']++ 计入数组中，这样的数组我们称之为哈希表，这种哈希表也是最简单的，如果说为了方便直接调用哈希表，那这个哈希表该如何模拟呢？这个问题也是今天我们所探讨的，手撕哈希表。⭐主体。
C++ 实现哈希表的实例
08-29
主要介绍了C++ 实现哈希表的实例的相关资料,这里使用C++实现哈希表的实例帮助大家彻底理解哈希表的原理，需要的朋友可以参考下
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
哈希表 哈希表_使用C++实现的哈希表_HashTable
哈希表-使用C++实现的分布式哈希表.zip
03-04
哈希表 哈希表_使用C++实现的分布式哈希表
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 157
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 172
UE5 C++ 的FString类型取值问题。
多线程测试+互斥锁（1）【C++】
weixin_45690131的博客
05-10 232
多线程测试
C++小程序：同一路由器下两台计算机简单通信（1/2）——服务器端
m0_72128260的博客
05-12 895
同一路由器下两台电脑如何进行通信呢？这里通过小程序实例的方式介绍SOCKET结构体以及相关函数的使用。
2024OD机试卷-手机App防沉迷系统 (java\python\c++)
WRJ_Jack的博客
05-12 71
智能手机方便了我们生活的同时，也侵占了我们不少的时间。 “手机App防沉迷系统”能够让我们每天合理地规划手机App使用时间，在正确的时间做正确的事。 它的大概原理是这样的： 1. 在一天24小时内，可以注册每个App的允许使用时段 2. 一个时间段只能使用一个App，举例说明：不能同时在9:00-10:00注册App2和App3 3. App有优先级，数值越高，优先级越高。注册使用时段时，如果高优先级的App时间和低优先级的时段有冲突，则系统会自动注销低优先级的时段，如果App的优先级相 同，则后添加的Ap
c++如何实现哈希表
06-01
C++中可以使用STL中的unordered_map来实现哈希表。unordered_map是一个基于哈希表实现的关联容器，可以快速地插入、查找和删除键值对。 下面是一个简单的示例代码，实现了一个存储字符串的哈希表： ```c++ #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值