【 C++ 】开散列哈希桶的模拟实现

最新推荐文章于 2024-05-20 22:11:41 发布
最新推荐文章于 2024-05-20 22:11:41 发布
阅读量754 收藏 22
点赞数 21
分类专栏： C++ 文章标签： 哈希算法 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JX_BC/article/details/136081231
版权

哈希桶大概框架

根据我们先前对开散列哈希桶的了解，得知其根本就是一个指针数组，数组里每一个位置都是一个链表指针，因此我们要单独封装一个链表结构的类，以此来告知我们哈希表类的每个位置为链表指针结构。

namespace Bucket
{
	//桶结点
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		//构造函数
		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{}
	};
	//哈希表
	template<class K, class V, class HashFunc = DefaultHash<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		//相关功能的实现……
	private:
		//指针数组
		vector<Node*> _tables;
		size_t _n = 0;//记录有效数据的个数
	};
}

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

此步操作的方法和闭散列哈希表所实现的步骤一致，目的都是为了能够让后续操作中传入的所有数据类型转换为整型数据，以此方便后续建立映射关系，直接看代码：

//利用仿函数将数据类型转换为整型
	template<class K>
	struct DefaultHash
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	//模板的特化
	template<>
	struct DefaultHash<std::string>
	{
		size_t operator()(const std::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. 当负载因子==1时扩容 。
  2. 扩容后重新建立映射关系 。
  3. 创建一个新的哈希桶对象，扩容到newSize的大小。
  4. 遍历旧表，把旧表每个存在的元素插入到新表，此步骤让新表自动完成映射关系，无序手动构建。
  5. 利用swap函数把新表交换到旧表那，此时的旧表就是已经扩好容且建立号映射关系的哈希表。

此扩容的方法会存在一个问题：释放旧表会出错！！！

  • 当我们把旧表的元素映射插入到新表的时候，最后都要释放旧表，按照先前哈希表的释放，我们无需做任何处理，但是现在定义的结构是vector，是自定义类型，会自动调用析构函数进行释放，vector存储的数据是Node*，Node*是内置类型，不会自动释放，最后会出现表我们释放了，但是链表结构的数据还没释放，因此，我们还需借助手写析构函数来帮助我们释放。
//析构函数
~HashTable()
{
	for (size_t i = 0; i < _tables.size(); i++)
	{
		Node* cur = _tables[i];
		while (cur)
		{
			Node* next = cur->_next;
			delete cur;
			cur = next;
		}
		_tables[i] = nullptr;//释放后置空
	}
}

此扩容的方法可以进行优化，见法二。

法二：

  • 这里我们没必要再创建新的节点，相反把扩容前的节点拿过来重新映射到新表中，大体逻辑和前面差不太多，只是这里不需要再创建新节点。直接利用原链表里的节点。

3、头插操作：

  1. 借助仿函数找到映射的位置（头插的位置）。
  2. 进行头插的操作。
  3. 更新有效数据个数。

在这里插入图片描述

//插入
bool Insert(const pair<K, V>& kv)
{
	//1、去除冗余
	if (Find(kv.first))
	{
		return false;
	}
	//构建仿函数，把数据类型转为整型，便于后续建立映射关系
	HashFunc hf;
	//2、负载因子 == 1就扩容
	if (_tables.size() == _n)
	{
		/*法一
		size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
		HashTable<K, V> newHT;//
		newHT._tables.resize(newSize, nullptr);
		//遍历旧表，把旧表的数据重新映射到新表
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)//如果cur不为空，就插入
			{
				newHT.Insert(cur->_kv);
				cur = cur->_next;
			}
		}
		newHT._tables.swap(_tables);*/
 
		//法二：
		size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
		vector<Node*> newTable;
		newTable.resize(newSize, nullptr);
		for (size_t i = 0; i < _tables.size(); i++)//遍历旧表
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				size_t hashi = hf(cur->_kv.first) % newSize;//确认映射到新表的位置
				//头插
				cur->_next = newTable[hashi];
				newTable[hashi] = cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
		newTable.swap(_tables);
	}
	//3、头插
	//找到对应的映射位置
	size_t hashi = hf(kv.first);
	hashi %= _tables.size();
	//头插到对应的桶即可
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

哈希桶的查找

遵循下列规则：

  1. 先去判断表的大小是否为0，为0直接返回nullptr。
  2. 利用仿函数去找到映射的位置。
  3. 在此位置往后的一串链表中进行遍历查找，找到了，返回节点指针。
  4. 遍历结束，说明没找到，返回nullptr。
//查找
Node* Find(const K& key)
{
	//防止后续除0错误
	if (_tables.size() == 0)
	{
		return nullptr;
	}
	//构建仿函数，把数据类型转为整型，便于后续建立映射关系
	HashFunc hf;
	//找到对应的映射下标位置
	size_t hashi = hf(key);
	//size_t hashi = HashFunc()(key);//匿名对象
	hashi %= _tables.size();
	Node* cur = _tables[hashi];
	//在此位置的链表中进行遍历查找
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			//找到了
			return cur;
		}
		cur = cur->_next;
	}
	//遍历结束，没有找到，返回nullptr
	return nullptr;
}

哈希桶的删除

哈希桶的删除遵循这两大思路：

  1. 找到删除的值对应哈希桶的下标映射位置。
  2. 按照单链表删除节点的方法对该值进行删除。
//删除
bool Erase(const K& key)
{
	//防止后续除0错误
	if (_tables.size() == 0)
	{
		return false;
	}
	//构建仿函数，把数据类型转为整型，便于后续建立映射关系
	HashFunc hf;
	//找到key所对应的哈希桶的位置
	size_t hashi = hf(key);
	hashi %= _tables.size();
	Node* cur = _tables[hashi];
	Node* prev = nullptr;
	//删除
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (prev == nullptr)//头删
			{
				_tables[hashi] = cur->_next;
			}
			else//非头删
			{
				prev->_next = cur->_next;
			}
			delete cur;
			return true;
		}
		prev = cur;
		cur = cur->_next;
	}
	return false;
}

法二：替换法删除

  • 上述的删除是实打实的删除，建立prev作为cur的前指针，以此利用prev和cur->next来建立关系从而删除cur节点，但是我们可以不用借助prev指针，就利用先前二叉搜索树的替换法删除的思想来解决。图示：

在这里插入图片描述

  1. 当我要删除88时，把节点88的下一个节点的值78替换掉88，随后删除节点78，再建立链表的关系即可。
  2. 当删除的是尾节点98时，直接和头节点进行交换，删除头节点，并建立链表关系。

这里就不代码演示了，因为整体的成本看还是法一更方便理解些。

完整代码

#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 Bucket
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		//构造函数
		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{}
	};
	template<class K, class V, class HashFunc = DefaultHash<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		//析构函数
		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;//释放后置空
			}
		}
		//插入
		bool Insert(const pair<K, V>& kv)
		{
			//1、去除冗余
			if (Find(kv.first))
			{
				return false;
			}
			//构建仿函数，把数据类型转为整型，便于后续建立映射关系
			HashFunc hf;
			//2、负载因子 == 1就扩容
			if (_tables.size() == _n)
			{
				/*法一
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newHT;//
				newHT._tables.resize(newSize, nullptr);
				//遍历旧表，把旧表的数据重新映射到新表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)//如果cur不为空，就插入
					{
						newHT.Insert(cur->_kv);
						cur = cur->_next;
					}
				}
				newHT._tables.swap(_tables);*/

				//法二：
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTable;
				newTable.resize(newSize, nullptr);
				for (size_t i = 0; i < _tables.size(); i++)//遍历旧表
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hf(cur->_kv.first) % newSize;//确认映射到新表的位置
						//头插
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				newTable.swap(_tables);
			}
			//3、头插
			//找到对应的映射位置
			size_t hashi = hf(kv.first);
			hashi %= _tables.size();
			//头插到对应的桶即可
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}
		//查找
		Node* Find(const K& key)
		{
			//防止后续除0错误
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			//构建仿函数，把数据类型转为整型，便于后续建立映射关系
			HashFunc hf;
			//找到对应的映射下标位置
			size_t hashi = hf(key);
			//size_t hashi = HashFunc()(key);//匿名对象
			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			//在此位置的链表中进行遍历查找
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//找到了
					return cur;
				}
				cur = cur->_next;
			}
			//遍历结束，没有找到，返回nullptr
			return nullptr;
		}
		//删除
		/*法一*/
		bool Erase(const K& key)
		{
			//防止后续除0错误
			if (_tables.size() == 0)
			{
				return false;
			}
			//构建仿函数，把数据类型转为整型，便于后续建立映射关系
			HashFunc hf;
			//找到key所对应的哈希桶的位置
			size_t hashi = hf(key);
			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			//删除
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)//头删
					{
						_tables[hashi] = cur->_next;
					}
					else//非头删
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
		/*法二替换法……*/

	private:
		//指针数组
		vector<Node*> _tables;
		size_t _n = 0;//记录有效数据的个数
	};
}
.滄海难为水
关注
  • 21
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表开散列哈希桶实现
01-07
开散列法对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成 一个向量，因此，向量的元素个数与可能的...
C++ 实现哈希表的实例
08-29
主要介绍了C++ 实现哈希表的实例的相关资料,这里使用C++实现哈希表的实例帮助大家彻底理解哈希表的原理，需要的朋友可以参考下
C++--哈希表--开散列（哈希桶的模拟实现）--1110
qq_68741368的博客
11-11 356
手把手教你模拟开散列的哈希表
C++开散列(哈希桶)的模拟实现
Arthur__Cui的博客
07-22 78
插入数据之前一般要用**负载因子(有效数据个数/容器大小)**判断是否要扩容，一般的如闭散列的负载因子控制在0.7-0.8左右，但是这个哈希桶由于其链式结构特殊，只需等到数据放满(负载因子 == 1)再扩容即可。C++哈希开散列，又称哈希桶，是为了解决哈希冲突而诞生的方法。、以及里面的**插入Insert()**函数、**删除Erase()**函数、**查找Find()**函数、以及测试函数等。但若出现范围差距过大，如1，2，1000，2的情况，不可能开一个大小为1000的容器，所以想到了。
【C++】开散列哈希表封装实现unordered_map和unordered_set
The porters of knowledge
04-05 811
unordered系列关联式容器，哈希冲突和哈希函数，闭散列和开散列哈希表的实现，用闭散列哈希表封装实现unordered_set和map，封装实现时哈希表特殊的const迭代器……
C++ | 哈希 | 开散列结构的模拟实现 | 迭代器和泛型的封装
凡事都是靠练习
01-22 589
C++模拟实现开散列结构，并且封装泛型与迭代器
C++哈希函数_哈希表_哈希冲突_负载因子_仿函数_针对字符串的模板特化特化_闭散列(线性探测)哈希表_开散列哈希桶的模拟实现(Key_Value模型数组)
dodamce的博客
12-25 1391
文章目录1.哈希中的基本概念哈希函数常见的哈希函数与缺陷哈希表2.哈希冲突哈希冲突的解决方法(闭散列与开散列)闭散列(开放地址法)负载因子C++实现除留余数法闭散列线性探测哈希表(Key_Value模型)开散列(哈希桶/拉链法)C++实现除留余数法开散列哈希桶(Key_Value模型)3.代码位置 1.哈希中的基本概念 哈希函数 之前的二叉搜索树与红黑树以及顺序结构他们的关键字和它的储存位置没有对应关系，所以在查找一个元素时要经过多次的关键字比较。 顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(l
哈希桶（开散列）的模拟实现以及其中哈希桶迭代器的模拟实现
liuming
11-20 167
开散列（哈希桶）：将发生哈希冲突的元素以链表的方式串联起来，本质上是衣服一个链表的集合。 哈希桶的大概结构如上图，可以理解为一个数组中每一个位置存储的是一个链表。 下面大概介绍哈希桶的大概实现： 首先定义存储的节点，此节点跟链表的节点雷同，next存储下一个节点的位置，data存储值域： template<class T> struct hashBucketNode { hashBucketNode(const T& x=T()) :next(nullptr) .
【C++】哈希表模拟实现
m0_69442905的博客
10-10 981
了解哈希表的几种实现方式，初步了解哈希函数，初步构建简单的封闭哈希表，实现插入，查找，删除等。然后对封闭哈希表基础上进行更新，引出介绍链式哈希表，实现最简单的插入查找，删除
【 C++ 】闭散列哈希表的模拟实现
bit_zyx的博客
09-24 568
目录 1、框架 2、哈希节点状态的类 3、哈希表的扩容 4、构建仿函数把所有数据类型转换为整型并特化 5、哈希表的插入 6、哈希表的查找 7、哈希表的删除 8、源码链接
JavaSE_Java实现开散列哈希桶，测试重载hashCode方法
dodamce的博客
06-28 158
C++哈希函数_哈希表_哈希冲突_负载因子_仿函数_针对字符串的模板特化特化_闭散列(线性探测)哈希表_开散列哈希桶的模拟实现(Key_Value模型数组具体思路看上面的链接，这里直接给出Java代码
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
哈希表 哈希表_使用C++实现的哈希表_HashTable
散列查找算法_哈希表
12-08
编写程序实现对给定数组序列进行散列表的建立，并在建立散列表的基础上进行查找，并返回查找成功与否. 首先定义一个固定长度的列表data,以及一个比列表长度大的哈希表,并初始化为0. 程序先调用自己写的Create函数...
c语言操作注意事项
dropLin的博客
05-20 114
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 898
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 412
一篇文章带你学会结构体的内存对齐！！超多精美配图！
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
C语言自定义类型:结构体
最新发布
wer24_25的博客
05-20 866
本文详细讲解了结构体的创建和结构体的内存对齐,还涉及了结构体的传参和结构体实现位段,轻松易懂,小白可入.
解决哈希冲突的开散列方法
05-23
开散列也叫做哈希表中的链地址法，是一种解决哈希冲突的方法。开散列的基本思想是将哈希表中的每个位置都指向一个链表或者其他数据结构，如果发生哈希冲突，就将冲突的元素加入到对应位置的链表中。 开散列的实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值