【数据结构】哈希桶

已于 2024-04-26 19:33:56 修改
阅读量1k 收藏 23
点赞数 21
文章标签： 数据结构 散列表
于 2024-04-25 18:43:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58963318/article/details/138191818
版权

目录

前言：

开散列（哈希桶）

开散列的概念

哈希桶的模拟实现

 整体框架

查找

插入

删除

析构函数

拷贝构造函数

赋值运算符重载

哈希桶模拟实现源码

前言：

闭散列线性探测缺点：一旦发生哈希冲突，所有的产生哈希冲突的数据连续存储在一块区域，容易产生数据"堆积"，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低，并且闭散列导致空间利用率低，因此本文探索采用开散列（哈希桶）的数据结构从而避免数据 "堆积" ；

开散列（哈希桶）

开散列的概念

开散列法又叫链地址法(拉链法)，首先对关键码集合用哈希函数计算哈希地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链

接起来，各链表的头结点存储在哈希表中；

哈希桶的模拟实现

 整体框架

template<class K, class V>
struct HashNode
{
	HashNode<K, V>* _next;
	pair<K, V> _kv;
    
    //开辟结点时需要结点的构造函数
	HashNode(const pair<K, V>& kv)
	{
		_kv = kv;
		_next = nullptr;
	}
};

template<class K, class V>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	//...
private:
	vector<Node*> _tables;
	size_t _n;//记录哈希表中实际存放的数据个数
};

查找

思路：

首先根据键值key使用哈希函数计算哈希地址，确定待查找的数据的位置；

其次遍历桶中数据，查找到返回数据所在结点的指针，查找不到返回空指针；

Node* Find(const K& key)
{
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	while (cur != nullptr)
	{
		if ((cur->_kv).first == key)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return nullptr;
}

插入

开散列最优情形：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，考虑哈希表扩容；

  • 查看哈希表中是否存在该键值的键值对，若已存在则插入失败；
  • 当负载因子增加到1时，进行扩容操作（即创建一个新的哈希表，该哈希表的大小为原哈希表的两倍，然后遍历原哈希表，将原哈希表中的结点插入到新哈希表，最后将原哈希表与新哈希表交换即可）；
  • 将结点插入哈希桶（头插）；
  • 哈希表中的记录实际存储的数据个数自增1；
//构造函数
HashTable(size_t n = 10)
{
	_tables.resize(n, nullptr);
	_n = 0;
}
bool Insert(const pair<K, V>& kv)
{
	//若键值对中的键值key已存在，则插入失败
	Node* ret = Find(kv.first);
	if (ret != nullptr)
	{
		return false;
	}

	//控制负载因子为1，即哈希表中实际存放的数据个数与哈希表长度长度相等
	if (_n == _tables.size())
	{
		//新表扩容到旧表的两倍
		vector<Node*> _newtables(_tables.size() * 2);
		//遍历旧表,取旧表结点头插到新表
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur != nullptr)
			{
				Node* nextnode = cur->_next;
		
				size_t hashi = cur->_kv.first % _newtables.size();
				cur->_next = _newtables[hashi];
				_newtables[hashi] = cur;

				cur = nextnode;
			}
			_tables[i] = nullptr;
		}

		//交换新表与旧表
		_tables.swap(_newtables);
	}

	//插入
	//计算插入位置
	size_t hashi = kv.first % _tables.size();
	Node* newnode = new Node(kv);

	//单链表头插
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;

	++_n;
	return true;
}

删除

bool Erase(const K& key)
{
	//确定待删除数据的位置
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	Node* prev = nullptr;
	while (cur != nullptr)
	{
		if ((cur->_kv).first == key)
		{
			//删除
			if (prev != nullptr)
			{
				prev->_next = cur->_next;
			}
			else
			{
				_tables[hashi] = cur->_next;
			}
			delete cur;

			--_n;
			return true;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
	return false;
}

析构函数

//析构函数
~HashTable()
{
	for (size_t i = 0; i < _tables.size(); i++)
	{
		Node* cur = _tables[i];
		while (cur != nullptr)
		{
			Node* next = cur->_next;
			delete cur;
			cur = next;
		}
		_tables[i] = nullptr;
	}
}

当哈希表中的HashNode存储string时，string类型的数据不支持取模运算，若采用运算符重载，需要更改库中的string，除留余数法如何建立string类型数据与存储位置的映射关系吗?

解决方案：

  1. 首先将string类型转换为整型，建立string类型与整型的映射关系（采用仿函数实现）；
  2. 其次转换后的整型值与存储位置建立映射关系（模版参数增加1个接收仿函数）；

思考：任意类型的值如何转换为整型值 ？

  • 本身为整型家族的成员，则可以通过强制类型转换可以转化为整型；
  • 对于string类型，可以取每个字符的ASCII码值，逐个相加且每相加一次乘以权重31；
  • 对于其他类型，按数据类型各自的特征自定义仿函数实现转换为整型；
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

//string类型使用模版的特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash += e;
			hash *= 31;//BKDR字符串哈希算法,累乘因子为31
		}
		return hash;
	}
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	//...
private:
	vector<Node*> _tables;
	size_t _n;//记录哈希表中实际存放的数据个数
};

拷贝构造函数

//拷贝构造函数  ht2(ht1)
HashTable(const HashTable& ht)
{
	Hash hs;
	//开辟相同大小的空间
	_tables.resize(ht._tables.size());
	//遍历旧表,头插到新表
	for (size_t i = 0; i < ht._tables.size(); i++)
	{
		Node* cur = ht._tables[i];
		while (cur != nullptr)
		{
			Node* next = cur->_next;

			//计算新表的插入位置
			size_t hashi = hs(cur->_kv.first) % _tables.size();

			cur->_next = _tables[hashi];
			_tables[hashi] = cur;
			cur = next;
		}
	}
	_n = ht._n;
}

赋值运算符重载

//赋值运算符重载 ht2=ht1
HashTable& operator=(HashTable ht)
{
	_tables.swap(ht._tables);
	swap(_n, ht._n);

	return *this;
}

哈希桶模拟实现源码

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

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto e : s)
		{
			hash += e;
			hash *= 31;
		}

		return hash;
	}
};

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

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	//构造函数
	HashTable(size_t n = 10)
	{
		_tables.resize(n, nullptr);
		_n = 0;
	}
	//析构函数
	~HashTable()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur != nullptr)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
	}
	//拷贝构造函数  ht2(ht1)
	HashTable(const HashTable& ht)
	{
		Hash hs;
		//开辟相同大小的空间
		_tables.resize(ht._tables.size());
		//遍历旧表,头插到新表
		for (size_t i = 0; i < ht._tables.size(); i++)
		{
			Node* cur = ht._tables[i];
			while (cur != nullptr)
			{
				Node* next = cur->_next;

				//计算新表的插入位置
				size_t hashi = hs(cur->_kv.first) % _tables.size();

				cur->_next = _tables[hashi];
				_tables[hashi] = cur;
				cur = next;
			}
		}
		_n = ht._n;
	}

	//ht2=ht1
	HashTable& operator=(HashTable ht)
	{
		_tables.swap(ht._tables);
		swap(_n, ht._n);

		return *this;
	}

	Node* Find(const K& key)
	{
		Hash hs;
		size_t hashi = hs(key) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur != nullptr)
		{
			if ((cur->_kv).first == key)
			{
				return cur;
			}
			cur = cur->_next;
		}
		return nullptr;
	}


	bool Insert(const pair<K, V>& kv)
	{
		//若键值对中的键值key已存在，则插入失败
		Node* ret = Find(kv.first);
		if (ret != nullptr)
		{
			return false;
		}

		//控制负载因子为1，即哈希表中实际存放的数据个数与哈希表长度长度相等
		if (_n == _tables.size())
		{
			//新表扩容到旧表的两倍
			vector<Node*> _newtables(_tables.size() * 2);
			//遍历旧表,取旧表结点头插到新表
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur != nullptr)
				{
					Node* nextnode = cur->_next;
					Hash hs;
					size_t hashi = hs(cur->_kv.first) % _newtables.size();
					cur->_next = _newtables[hashi];
					_newtables[hashi] = cur;

					cur = nextnode;
				}
				_tables[i] = nullptr;
			}

			//交换新表与旧表
			_tables.swap(_newtables);
		}

		//插入
		//计算插入位置
		Hash hs;
		size_t hashi = hs(kv.first) % _tables.size();
		Node* newnode = new Node(kv);

		//单链表头插
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;

		++_n;
		return true;
	}

	bool Erase(const K& key)
	{
		Hash hs;
		//确定待删除数据的位置
		size_t hashi = hs(key) % _tables.size();
		Node* cur = _tables[hashi];
		Node* prev = nullptr;
		while (cur != nullptr)
		{
			if ((cur->_kv).first == key)
			{
				//删除
				if (prev != nullptr)
				{
					prev->_next = cur->_next;
				}
				else
				{
					_tables[hashi] = cur->_next;
				}
				delete cur;

				--_n;
				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}
private:
	vector<Node*> _tables;
	size_t _n;//记录哈希表中实际存放的数据个数
};

欢迎大家批评指正，博主会持续输出优质内容，谢谢各位观众老爷观看，码字画图不易，希望大家给个一键三连支持~ 你的支持是我创作的不竭动力~

小呆瓜历险记
关注
  • 21
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
C++数据结构哈希表
04-01
链地址法则是在每个哈希桶中维护一个链表，所有映射到该位置的关键字都存储在这个链表中。C++的`std::unordered_map`和`std::unordered_set`采用的就是链地址法。 `std::unordered_map`用于存储键值对，其中键是...
数据结构学习笔记.zip
06-17
此外，哈希表也是数据结构中的重要一环。它利用哈希函数将数据映射到固定大小的桶中，实现快速的查找、插入和删除操作，平均时间复杂度为O(1)。虽然哈希冲突可能导致性能下降，但通过优秀的哈希函数设计和解决冲突...
C++数据结构——哈希桶HashBucket
m0_75186846的博客
05-26 933
哈希桶（Hash Bucket）是哈希表中用来存储哈希冲突的一个位置。当多个键通过哈希函数映射到同一个索引时，这些键值对被存储在同一个桶中。哈希桶通常采用链表或其他数据结构来存储这些冲突的元素。这种方法被称为“链地址法”，它允许多个键值对共享同一个哈希表索引，从而有效解决哈希冲突问题。
【数据结构】哈希表与哈希桶
℉f的博客
03-20 2477
本篇文章我们共同学习哈希结构，哈希结构追求更极致的搜索效率。之前学习的结构中搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O(N)，平衡树中查找的时间复杂度为树的高度O(logN)。那我们能不能构建一种数据结构，让搜索效率达到O(1)呢。如果构造一种存储结构，该结构能够通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时就能通过该函数很快找到该元素进而达到O(1)的查找效率。接下来就让我们共同学习哈希结构。
数据结构进阶 哈希桶
小萌新的博客
01-22 878
模拟实现高阶数据结构 哈希桶
哈希表、哈希桶数据结构以及刨析HashMap源码中哈希桶的使用
ZJRUIII的博客
01-26 2333
文章目录一、哈希表1.哈希表概念2.冲突的概念3.避免冲突与解决冲突3.1 避免冲突的方式1——哈希函数的设计3.2 避免冲突的方式2——负载因子的调节3.3 解决冲突的方式1——闭散列3.4 解决冲突的方式2——开散列、哈希桶(重要)4.哈希表查找成功与查找失败的求法4.1 查找成功的求法4.2 查找失败的求法二、用泛型实现开散列与开散列在源码上的底层实现1.用泛型实现开散列2.开散列在源码上的底层实现2.1 HashMap底层面试题 一、哈希表 1.哈希表概念 可以不经过任何比较，一次直接从表中得到要搜
程序员必备数据结构知识
08-29
- `hashCode()` 方法用于将对象映射到哈希桶，而 `equals()` 方法则用于判断两个键是否表示同一个对象，这对于查找和更新键值对至关重要。 3. **二叉树的非递归遍历**： - 二叉树遍历包括前序遍历、中序遍历和...
数据结构知识框架1
08-03
本文将详细解析数据结构中的B树、B+树以及哈希搜索和排序的相关知识点。 首先，B树是一种自平衡的多叉树，它的特性保证了数据的平衡分布，从而提供高效的查找、插入和删除操作。B树的主要性质如下： 1. 根节点至少...
数据结构课程设计——哈希表
06-07
链地址法则是每个哈希桶内维护一个链表，所有哈希到同一位置的元素都链接在这个链表上；再哈希法则会使用另一个不同的哈希函数来解决冲突。 在具体实现哈希表时，需要考虑的主要因素有负载因子（已存元素数量与哈希...
[数据结构] 基于交换的排序 冒泡排序&&快速排序
水墨不写bug
07-06 1085
让右下标先走，向左寻找比key小的值，找到后停下来：停下来后：左下标再向右寻找比key大的值，找到后停下来：此时，交换两个下标对应的值：接下来继续执行上述步骤（R先走），我展示关键步骤：两下标找到要求目标并交换：直到遇到特殊情况：两下标相遇这时停止停止循环，将最左侧元素与相遇处的元素交换位置：即可完成一次二分。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1134
插入排序&&希尔排序 实现原理
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
架构筑梦的Cherry Yang的博客
07-06 1114
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
数据结构第07节：队列
hummhumm的专栏
07-04 571
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
6、Redis系统-数据结构-03-压缩列表
最新发布
qq_29434541的博客
07-07 1165
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
【初阶数据结构】深入解析循环队列:探索底层逻辑
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
07-04 1961
本篇将介绍如何实现循环队列并实现过程需要注意的事项，虽然篇幅较小，但是其中逻辑还是值得引人思考的，循环队列可以采用数组或链表实现，这篇将采用数组实现循环队列
数据结构--顺序表
LH__1314的博客
06-30 4968
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构--单链表实现
LH__1314的博客
07-05 1317
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
哈希表数据结构+c++
10-21
哈希表是一种基于哈希函数实现的数据结构，它可以快速地进行插入、查找和删除操作。在哈希表中，每个元素都有一个关键字(key)，哈希函数将关键字映射到一个桶(bucket)中，桶中存储着具有相同哈希值的元素。哈希表的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小呆瓜历险记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值