哈希/散列--哈希表[思想到结构]

最新推荐文章于 2024-05-21 20:29:42 发布
最新推荐文章于 2024-05-21 20:29:42 发布
阅读量116 收藏
点赞数
分类专栏： 遣返回家的C家家 文章标签： 哈希算法 散列表 算法 学习 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/133500622
版权

文章目录


在这里插入图片描述

1.何为哈希?

1.1百度搜索

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

1.2自身理解

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应关系
在查找一个元素时，必须要经过key的多次比较。
顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN).

有没有这样一种方法 不经过任何比较 直接从表中得到要查找的元素。

大佬神作: 构造一种存储结构，通过某种函数使元素的存储位置与key之间建立一一映射的关系，在查找时通过该函数找到该元素.

1.3哈希方法/散列方法

插入元素:
将待插入元素的key，以某个函数[哈希函数/散列函数]计算出该元素的存储位置并按此位置存放,构造出一个结构[哈希表/散列表]
搜索元素:
对元素的key进行同样的计算，求得的函数值即为元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
在这里插入图片描述

1.4哈希冲突/哈希碰撞

  • 不同关键码通过哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞.
  • 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

在这里插入图片描述

1.5如何解决?

哈希函数的设计

设计一个合理的哈希函数

哈希函数设计原则：

  1. 简单方便
  2. 哈希函数要使得关键码均分分布
  3. 定义域为所有key 值域为[0, n)

常见哈希函数

  • 直接定址法–(常用)
    取关键字的某个线性函数为散列地址：Hashi（Key）= A*Key + B
    优点：简单、均匀
    缺点：需要事先知道关键字的分布情况 否则导致—数据量小 但是需要的空间极大 例如 :数据-1 2 3 9999下标: 1 2 3 9999
    使用场景：数值小且分布集中
  • 除留余数法–(常用)
    设散列表中允许地址数为n，除数p的取值规则: 小于等于n 接近/等于n的质数
    哈希函数：Hashi(key) = key % p(p <= n)
  • 平方取中法–(了解)
    假设关键码为6392，它的平方为40857664，抽取中间的3位857或576作为hashi；
    使用场景：不知道关键码的分布 位数不是很大
  • 折叠法–(了解)
    将关键码从左到右分割成位数近似相等的几部分 将这几部分叠加求和
    按散列表表长 取后几位作为hashi
    使用场景：无所谓关键码的分布 位数较大
  • 随机数法–(了解)
    选择一个随机函数，取关键字的随机函数值为它的哈希地址，即Hashi(key) = random(key)
    使用场景：关键字长度不等
  • 数学分析法–(了解)
    假设关键字为某一地区的手机号，大部分前几位都相同的 取后面的四位作为hashi
    还出现冲突–对抽取数字进行反转(如1234改成4321)、右环移位(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等.
    使用场景：关键字位数比较大 事先知道关键字的分布 关键字的若干位分布较均匀
    == 注意：哈希冲突只可缓解 不可避免 ==

2.闭散列和开散列

2.1闭散列/开放定址法

当发生哈希冲突时，如果哈希表未被装满，把key存放到冲突位置的==“下一个” ==空位置
寻找空位置:

  1. 线性探测
    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置
    在这里插入图片描述

插入:

  • 通过哈希函数获取待插入元素在哈希表中的位置
  • 该位置没有元素直接插入新元素
  • 该位置中有元素 使用线性探测找到下一个空位置 插入新元素
    在这里插入图片描述

删除:

  • 线性探测采用标记的伪删除法来删除一个元素
  • 若直接删除 会影响其他元素的搜索
    例如上图: 删除对象是33 直接删除 hash6 这个位置应该怎么办? 需要搞一个东西让哈希表的使用者知道这里原来有元素 现在被删除了 置成null? 如果置成空 当想要查找 1002/43即33后面的元素时 遇到hash6 使用者被告知这里是空 停止查找 此时使用者得到的信息是 哈希表中并不存在此元素 这与现实违背 那怎么办? 答案是置成"删除"状态 使得使用者知道何为空何为删除 这就是伪标记删除法

负载因子

哈希表的负载因子定义为: α = 表中的元素个数[ _n ] / 哈希表长[ _tables.size() ]
负载因子a: 哈希表装满程度的标志因子
表长是定值，α与_n成正比
α越大 填入表中的元素越多 哈希冲突可能性越大
α越小 填入表中的元素越少 哈希冲突可能性越小
哈希表的平均查找长度是负载因子α的函数 处理冲突方法不同函数不同
负载因子越大，冲突的概率越高，查找效率越低，空间利用率越高
负载因子越小，冲突的概率越低，查找效率越高，空间利用率越低

容量问题: 1.size是实际能够访问数据的范围 2.capacity是存储数据的空间大小

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

优点:

实现简单

缺点;

x占据y的位置 y就得放到y+1的位置
冲突累计 产生数据堆积
本意是要减缓哈希冲突
虽然使得有相同hashi的不同数据有位置存放
但是数据堆积时 会使得寻找某关键码的位置需要许多次比较
导致搜索效率降低。

  1. 二次探测
    线性探测寻找空位置的方法[逐个后移]导致线性探测的缺陷[产生冲突的数据堆积]
    修改探测的方法:
    在这里插入图片描述

2.2开散列/链地址法/开链法

1.概念

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

2.容量问题

桶的个数有限[即哈希表的表长有限]
随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容
某种情况下 每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，我们假定在元素个数刚好等于桶的个数时，进行扩容 即在这里插入图片描述
需要了解到是 我们最然控制α为1时进行扩容 并不代表此时哈希桶都挂了一个结点 更为普遍的情况是 一些桶为空 一些桶有许多结点 只不过结点总个数为哈希表长度大小

在这里插入图片描述

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

3.代码实现[配备详细注释]

3.1闭散列

//闭散列/开放地址法
namespace OpenAddressing
{
	//状态枚举
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	//哈希数据元素
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _pair;
		State _state = EMPTY;
	};

	//哈希表
	template<class K, class V>
	class HashTable
	{
	public:
		//插入函数
		bool Insert(const pair<K, V>& pair)
		{
			//值已存在 插入错误
			if (Find(pair.first))
				return false;

			//负载因子/荷载系数 -- Load_Factor = _n / _tables.size();

			//(double)_n / (double)_tables.size() >= 0.7
			//_n * 10 / _tables.size() >= 7

			//使得扩容发生的条件: size为0 负载因子达到阈值
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				/  低级代码  /
				/*
				//先更新size 由size作为参数扩容 解决只改容量 不更新访问范围的问题
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;

				//调用vector的有参构造[有参构造里调用reserve] 创建一个新表
				vector<HashData<K,V>> newtables(newsize);

				//遍历旧表  由哈希函数更新数据位置
				for (auto& e :  _tables)
				{
					if (e._state == EXIST)
					{
						//哈希函数计算出的下标
						size_t hashi = pair.first % newtables.size();

						//重新线性探测
						size_t index = hashi;//index代替hashi进行操作 保留原始hashi的值不变
						for (size_t i = 1; newtables[index]._state == EXIST; ++i)
						{
							index = hashi + i;        //从原始下标不断 +1 +2 +3 ...
							index %= newtables.size();//防止越界 只在表内定位index
						}

						//将数据放入合适位置
						newtables[index]._pair = e._pair;
						newtables[index]._state = EXIST;
					}
				}

				//新表的数据才是我们想要的数据 交换后 newtables中存放的变为旧数据
				//newtables是个局部变量 让其"自生自灭"
				_tables.swap(newtables);
				*/

				//  高级代码 //
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> other;
				other._tables.resize(newsize);

				for (auto& e : _tables)
				{
					if (e._state == EXIST)
						other.Insert(e._pair);
				}

				_tables.swap(other._tables);
				/

				//以上高级代码实际是对下面的线性探测进行了复用
			}

			//哈希函数计算出的下标
			size_t hashi = pair.first % _tables.size();

			// 线性探测
			size_t index = hashi;//index代替hashi进行操作 保留原始hashi的值不变
			for (size_t i = 1; _tables[index]._state == EXIST; ++i)
			{
				index = hashi + i;      //从原始下标不断 +1 +2 +3 ...
				index %= _tables.size();//防止越界 只在表内定位index
			}
			//将数据放入合适位置
			_tables[index]._pair = pair;
			_tables[index]._state = EXIST;
			_n++; //数据个数++

			return true;
		}

		//查找函数
		HashData<K, V>* Find(const K& key)
		{
			//哈希表为空 返回nullptr
			if (_tables.size() == 0)
				return nullptr;

			//哈希函数计算出的下标
			size_t hashi = key % _tables.size();

			// 线性探测
			size_t index = hashi;
			for (size_t i = 1; _tables[index]._state != EMPTY; ++i)
			{
				//obj是key的前提是obj存在
				if (_tables[index]._state == EXIST
					&& _tables[index]._pair.first == key)
				{
					return &_tables[index];
				}

				index = hashi + i;
				index %= _tables.size();

				//当表中元素状态非exist即delete时 
				//for循环判断条件一直为真 死循环
				//解决: 当找了一圈还未找到
				//表中无此key 返回false
				if (index == hashi)
					break;
			}
			return nullptr;
		}

		//删除函数
		bool Erase(const K& key)
		{
			HashData<K, V>* pos = Find(key);
			if (pos)
			{
				pos->_state = DELETE;
				--_n; //虽然已标记删除 仍然要使数据个数减减 防止有用数据未达到阈值就执行扩容
				return true;
			}
			else
				return false;
		}

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0;//存储的数据个数
	};
	//  测试函数  ///
	void TestHashTable()
	{
		int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
		HashTable<int, int> ht;
		//插入
		for (auto& e : a)
			ht.Insert(make_pair(e, e));
		//插入第8个数据 达到阈值  测试扩容
		ht.Insert(make_pair(15, 15));

		//查找 + 删除
		int tmp = 12;
		if (ht.Find(tmp))
			cout << tmp << "在" << endl;
		else
			cout << tmp << "不在" << endl;

		ht.Erase(tmp);

		if (ht.Find(tmp))
			cout << tmp << "在" << endl;
		else
			cout << tmp << "不在" << endl;
	}
}

3.2开散列

//开散列/链地址法
namespace ChainAddressing
{
	//结点类
	template<class K, class V>
	struct HashNode
	{
		HashNode<K, V>* _next;
		pair<K, V> _pair;

		HashNode(const pair<K, V>& pair)
			:_next(nullptr)
			, _pair(pair)
		{
		
		}
	};

	//哈希表类
	template<class K, class V>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		//析构函数
		~HashTable()
		{
			for (auto& ptr : _tables)
			{
				while (ptr)
				{
					//记录下一个结点
					Node* next = ptr->_next;
					//释放当前结点
					delete ptr;
					//更新ptr
					ptr = next;
				}

				ptr = nullptr;
			}
		}

		//查找函数
		Node* Find(const K& key)
		{
			//为空不查找 返回nullptr
			if (_tables.size() == 0)
				return nullptr;

			//哈希函数计算的下标
			size_t hashi = key % _tables.size();
			//首先得到表里的指针 即相当于每一个桶的头指针
			//[实际上 每一个桶就是一个链表 表中的ptr是每一个链表的哨兵指针]
			Node* ptr = _tables[hashi];

			while (ptr)
			{
				if (ptr->_pair.first == key)
					return ptr;
				ptr = ptr->_next;
			}

			return nullptr;
		}

		//删除函数
		bool Erase(const K& key)
		{
			//哈希函数计算的下标
			size_t hashi = key % _tables.size();
			//首先得到表里的指针 即相当于每一个桶的头指针
			//[实际上 每一个桶就是一个链表 表中的ptr是每一个链表的哨兵指针]
			Node* ptr = _tables[hashi];
			Node* prv = nullptr;

			while (ptr)
			{
				//当前值为目标值 执行删除操作
				if (ptr->_pair.first == key)
				{
					if (prv == nullptr)
						_tables[hashi] = ptr->_next;
					else
						prv->_next = ptr->_next;

					delete ptr;
					return true;
				}
				//当前值不为目标值 继续向下遍历
				else
				{
					prv = ptr;
					ptr = ptr->_next;
				}
			}
			return false;
		}

		//插入函数
		bool Insert(const pair<K, V>& pair)
		{
			//表中已有 返回false
			if (Find(pair.first))
				return false;

			//负载因子/荷载系数 -- Load_Factor = _n / _tables.size();
			//负载因子 == 1时扩容
			if (_n == _tables.size())
			{
				///  高级代码1.0  /
				/*
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newht;
				newht.resize(newsize);
				for (auto& ptr : _tables)
				{
					while (ptr) 
					{
						newht.Insert(ptr->_pair);
						ptr = ptr->_next;
					}
				}

				_tables.swap(newht._tables);
				*/

				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newtables(newsize, nullptr);
				//遍历旧表 取出旧表里每一个指针
				for (auto& ptr : _tables)
				{
					//ptr是旧表里存储的每一个指针
					//它指向当前哈希桶的首结点 即他存储的是首结点的地址
					while (ptr)
					{
						//算出 当前结点根据新哈希函数计算的新下标
						size_t hashi = ptr->_pair.first % newtables.size();

						//ptr是首结点的地址 ptr->_next为第二个结点的地址
						Node* next = ptr->_next;
						
						// 头插到新表
						ptr->_next = newtables[hashi];
						newtables[hashi] = ptr;
						
						//更新ptr 即向下遍历
						ptr = next;
					}
				}

				_tables.swap(newtables);
			}

			//哈希函数计算出的下标
			size_t hashi = pair.first % _tables.size();
			//链表头插
			Node* newnode = new Node(pair);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;        
			++_n;

			return true;
		}

	private:
		vector<Node*> _tables; // 指针数组
		size_t _n = 0;         // 存储有效数据个数
	};
  测试函数  //
	void TestHashTable1()
	{
		int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
		HashTable<int, int> ht;
		for (auto& e : a)
		{ 
			ht.Insert(make_pair(e, e));
		}

		ht.Insert(make_pair(15, 15));
		ht.Insert(make_pair(25, 25));
		ht.Insert(make_pair(35, 35));
		ht.Insert(make_pair(45, 45));
	}

	void TestHashTable2()
	{
		int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
		HashTable<int, int> ht;
		for (auto& e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Erase(12);
		ht.Erase(3);
		ht.Erase(33);
	}
}
阿猿收手吧！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
哈希表-使用C语言实现哈希表数据结构-HashTable.zip
03-04
哈希表 哈希表_使用C语言实现哈希表数据结构_HashTable
一个内存高效哈希映射和哈希集的c++实现- Tessil/sparse-map
01-27
一个内存高效哈希映射和哈希集的c++实现- Tessil/sparse-map-源码
哈希/散列--哈希表[思想到结构][==完结版==]
A progressive ape!
10-06 139
完结版.
哈希/散列--哈希表[思想到结构][==修订版==]
A progressive ape!
10-05 104
随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容。某种情况下 每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，我们假定在元素个数刚好等于桶的个数时，进行扩容 即。对元素的key进行同样的计算，求得的函数值即为元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
C++--哈希表--散列--冲突--哈希闭散列模拟实现--问答--1107
qq_68741368的博客
11-08 1451
一步步教你模拟实现闭散列的哈希表
【C++】哈希/散列详细解析
weixin_63449996的博客
05-18 995
这篇文章详细解析了哈希表/散列表，欢迎大家阅读。
Hash（哈希/散列）和Bloom Filter(布隆过滤器)
coderge's CSDN Blog.
10-25 1134
布隆过滤器背后的数学原理在于两个完全随机的数字冲突的概率很小，因此，可以在很小的误识别率条件下，用很少的空间存储大量信息。常见的补救误识别的办法是再在建立一个小的白名单，存储那些可能被误判的信息。由于布隆过滤器中只有简单的算术运算,因此它的速度很快，使用方便。
哈希---闭散列和开散列
sqjddb的博客
07-23 1148
哈希冲突、哈希表扩容
哈希查找/散列查找（HashSearch）
Attract's Blog
08-22 8268
哈希表/散列表： 1.什么是哈希表： 哈希表不同于线性表数表之处在于其查找关键字（key）时不需要遍历表，哈希表中的每一个元素都可以根据元素值计算出其存放的地址，从而达到查找时长为O（1）。 这就好比" 字典"，我们查找字典中的某个关键字（key）时，只需要查找目录即可找到该关键字（key）存放的页码（位置/地址），而查找的目录是有限的，且是线性的（常数阶/线性阶），所以无论字典存放的元素、关键字再多，我们也能通过目录快速定位查找到某个元素。 python中的 “字典(dict)” 就是如此，利用哈希表的
搜索结构之哈希表--线性探测法
qq_44544313的博客
08-14 4469
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(H...
Learning C++ No.24 【哈希/散列实战】
狂小伍的博客
05-27 1753
两万字详解哈希/散列实现和一点点的烦心编程使用
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
哈希表 哈希表_使用Java开发的哈希表_HashTable
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
哈希表 哈希表_使用C++实现的哈希表_HashTable
哈希表线性探测再散列（纯数字）
12-22
c代码实现哈希表线性探测再散列。关键字均为纯数字。查找时为单次查找，未加入循环
质数和约数
最新发布
2302_77099705的博客
05-21 1099
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 884
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 359
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
【算法刷题day60】Leetcode：84. 柱状图中最大的矩形
qq_45022758的博客
05-21 328
暂无84. 柱状图中最大的矩形代码随想录解析。
c语言线性探索再散列构建哈希表
05-25
下面是一个基于C语言实现的线性探测再散列哈希表的代码示例： ```c #include #include #include #define HASH_TABLE_SIZE 100 typedef struct _hash_node { char *key; char *value; } hash_node; typedef ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿猿收手吧！

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

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

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

打赏作者

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

抵扣说明：

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

余额充值