哈希用法及其底层详解+实现

news2024/11/25 18:37:49

troop主页
前面几章我们已经讲完了map和set的使用，及其底层，相信你已经会使用map和set了，今天我们学习hash，他可以说是map和set的亲兄弟

一 hash初步了解

首先，哈希的用法方面，我们先来看看hash的英文名
在这里插入图片描述
在这里插入图片描述
unordered这个单词就是无序的意思，哈希就是一个无序的map和set。所以使用方面，可以说是一模一样。
下面两个链接就是哈希的详细介绍。

unordered_map
unordered_set

既然map和set和hash几乎没区别，为什么会出现这个关联式容器呢？
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N log2​N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好
的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个
unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是
其底层结构不同，其中两个就是我们今天要说的哈希。

二 hash的底层结构

2.1hash概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素
时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即
O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
1.插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
2.搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)。

我们举个例子；如数组[1，7，6，4，5，9]，放入hash表中。
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。
如果数据很多呢？，比如在加一个 14，那他要放的位置跟4重合了。这就是哈希冲突。

2.2 解决哈希冲突

闭散列（开放定址法）
i=key%表的大小
如果i的位置已经有了数字，那就线性的向后走到空的位置插入

三，开放定址法模拟实现哈希表

enum State
	{
		EMPTY,//空
		EXIST,//在
		DELETE//删除
	};
	template<class K,class V>
	struct HashData
	{
		State _state = EMPTY;
		pair<K, V> _kv;
	};
	template<class K, class V,class Hash=HashFunc<K>>
	class HashTable
	{
	private:
		vector<HashData> _tables;
	}

这就是基本框架

find（）

i=key%表的大小，
如果i不是查找的值，就线性的向后找，遇到空就可以结束了；到了表的结尾位置要往回绕。
补充：冲突越多，效率就会越多，这里还引入了新的概念负载因子/荷载因子=实际存的数据个数/表的大小这个值要控制在0.7左右。

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

insert（）

insert包含了两个内容扩容+插入（线性探测）
扩容问题：
如果已经大于0.7就需要进行扩容，扩容——重新开一个大的空间，旧表的数据交给新表。

bool Insert(const pair<K, V> kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n * 10 / _tables.size() == 7)
			{
				HashTable<K, V> newHT(_tables.size()*2);
				for (auto& e : _tables)
				{
					if (_tables[e]._state == EXIST)
					{
						newHT.Insert(e._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			//线性探测
			size_t hashi = kv.first % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				++hashi;
				hashi%= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;
		}

Erase（）

删除的重点就是在于状态的修改，（数据不用真的删除，把状态修改成删除即可）

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				_n--;
				ret->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d11526a53c96454e8
为什么要设一个删除状态？，如果没有，假设我们这里删除了15，要找6就会发现找不到了，因为find走到空就结束了，多加一个删除状态就可完美的解决这个问题了。

转换整型

相信你发现了上面我们模拟实现的hash表有很大的缺陷，作为类模板上面的只能是当key为整型时才可以使用的，因为我们的hashi是用%出来的，而%只能作为整型才可以用，所以我们就要对其他的数据类型进行转换。这里就要分成种情况

  • 能直接强转成整型的
  • 不能直接强转成整型的，例如：string和Date（我们自己定义的类型）

我们可以写仿函数来解决这里的问题。

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 += e;
				hash = hash * 131;
			}
			return hash;
		}
	};

完整代码

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
namespace open_address
{
	enum State
	{
		EMPTY,//空
		EXIST,//在
		DELETE//删除
	};
	template<class K,class V>
	struct HashData
	{
		State _state = EMPTY;
		pair<K, V> _kv;
	};
	//特化
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			size_t hash = 0;
			for (auto& e : key)
			{
				hash += e;
				hash = hash * 131;
			}
			return hash;
		}
	};
	template<class K, class V,class Hash=HashFunc<K>>
	class HashTable
	{
	public:
		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				if (key==_tables[hashi]._kv.first && _tables[hashi]._state == EXIST)
				{
					return &_tables[hashi];
				}
				else
				{
					++hashi;
					hashi %= _tables.size();
				}
			}
			return nullptr;
		}
		bool Insert(const pair<K, V> kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n * 10 / _tables.size() == 7)
			{
				HashTable<K, V,Hash> newHT(_tables.size()*2);
				for (auto& e : _tables)
				{
					if (_tables[e]._state == EXIST)
					{
						newHT.Insert(e._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			//线性探测
			Hash hs;
			size_t hashi = hs(kv.first) % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				++hashi;
				hashi%= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;
		}

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				_n--;
				ret->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<HashData<K,V>> _tables;
		size_t _n = 0;//记录有多少个元素
	};
}

这里的string就是把字符全加起来的时候还乘上一个权值。因为string用的比较多所以我们可以给他特化。
然后就是改造上面我们写的代码，只要是有出现%就都要改。

四，哈希桶（开散列拉链法）模拟实现哈希表

4.1概念

一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同
关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。这就是闭散列的缺陷，那么如何缓解呢？
就要用到哈希桶的思想。
定义：
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
这个就是借助链表来完成的，每个有冲突的数不是向下寻找，而是链接在当前数子的下面。

4.2框架

template<class K, class V>
	struct HashNode
	{
		HashNode<K,V>* _next;
		pair<K, V> _kv;

		HashNode(const pair<K,V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};
	template<class K, class V>
	class HashTable
	{
	private:
	vector<HashNode<K,V>*>_tables;
	size_t _n;
	};

Insert（）

插入还是两个问题，扩容和插入
插入比较简单

			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

扩容问题，跟上面的闭散列类似，创建新表，把原来的旧表插入到新表当中。
这里的插入是负载因子到1的时候才需要扩容。

			//扩容：负载因子到1就进行扩容
			if (_n == _tables.size())
			{
				//创建新表
				vector<Node*> newtable(_tables.size() * 2, nullptr);
				//遍历旧表
				for (int i = 0; i < _tables.size(); i++)
				{
					//取出旧表中的数据，插入到新表当中
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hs(cur->_kv.first) % newtable.size();
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

Erase（）

bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//两种情况，有前一个or没有前一个
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi]->_next= cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

Find()

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

完整代码

namespace hash_bucket
{
	template<class K, class V>
	struct HashNode
	{
		HashNode<K,V>* _next;
		pair<K, V> _kv;

		HashNode(const pair<K,V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};
	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K,V> Node;
	public:
		~HashTable()
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;

					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		HashTable()
		{
			_tables.resize(10, nullptr);
			_n = 0;
		}
		bool Insert(const pair<K,V>& kv)
		{
			if (Find(kv.first))
				return false;
			Hash hs;
			//扩容：负载因子到1就进行扩容
			if (_n == _tables.size())
			{
				//创建新表
				vector<Node*> newtable(_tables.size() * 2, nullptr);
				//遍历旧表
				for (int i = 0; i < _tables.size(); i++)
				{
					//取出旧表中的数据，插入到新表当中
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hs(cur->_kv.first) % newtable.size();
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			return true;
		}
		Node* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//两种情况，有前一个or没有前一个
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi]->_next= cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _tables;
		size_t _n;
	};
	
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1652441.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

静态NAT

静态NAT

哈喽&#xff01;各位小伙伴们好久不见&#xff0c;最近由于工作的原因断更了一段时间&#xff0c;不过最近我都会把这些给补上&#xff0c;今天我们来学习一个简单的知识——静态NAT转换。 第一章 什么是NAT技术&#xff1f; 网络地址转换技术NAT&#xff08;Networ…
阅读更多...
HTTPS对于网站到底价值几何？

HTTPS对于网站到底价值几何？

现在HTTPS基本上已经是网站的标配了&#xff0c;很少会遇到单纯使用HTTP的网站。但是十年前这还是另一番景象&#xff0c;当时只有几家大型互联网公司的网站会使用HTTPS&#xff0c;大部分使用的都还是简单的HTTP&#xff0c;这一切是怎么发生的呢&#xff1f; 为什么要把网站…
阅读更多...
xv6源码分析 017

xv6源码分析 017

xv6源码分析 017 在buffer cache上面的就是logging层了&#xff0c;这一层主要的工作是维持每一个文件系统写入的操作的原子性。什么是原子性&#xff1f;通俗地来讲&#xff0c;原子性可以这样理解&#xff0c;如果一组操作&#xff08;或者一个操作&#xff09;在执行的时候…
阅读更多...
H5视频付费点播打赏影视系统程序全开源运营版

H5视频付费点播打赏影视系统程序全开源运营版

这是一款视频打赏源码&#xff0c;勿做非法用途&#xff0c;由用户亲测功能完善&#xff0c;源码仅用于学习使用&#xff0c;分享链接是用户云盘&#xff0c;具有时效性&#xff0c;感兴趣的可以去学习。 thinkphp开发&#xff0c;前后端分离设计&#xff0c;支持游客登陆、VIP…
阅读更多...
代码随想录算法训练营第四十二天| 01背包问题理论基础，416. 分割等和子集

代码随想录算法训练营第四十二天| 01背包问题理论基础，416. 分割等和子集

理论基础&#xff1a; 带你学透0-1背包问题&#xff01;| 关于背包问题&#xff0c;你不清楚的地方&#xff0c;这里都讲了&#xff01;| 动态规划经典问题 | 数据结构与算法_哔哩哔哩_bilibili很多同学对背包问题的理解程度都处于一种黑盒的状态&#xff0c;及时这道题目在力…
阅读更多...
【java】接口

【java】接口

什么是接口 接口当中存在的是对方法的定义&#xff0c;而不是对方法的具体实现。 为什么不实现这个方法呢&#xff1f; 继承的本质是代码的复用。当一个父类会经常被继承&#xff0c;并且子类都要自己实现方法时&#xff0c;父类中的方法就会显得累赘&#xff0c;并且占用了…
阅读更多...
【JavaEE精炼宝库】计算机是如何工作的

【JavaEE精炼宝库】计算机是如何工作的

目录 前言&#xff1a; 一、冯诺依曼体系 二、CPU基本知识 2.1 硬盘|内存|CPU关系&#xff1a; 2.2 指令&#xff1a; 2.3 CPU是如何执行指令的&#xff08;重点&#xff09;&#xff1a; 2.4 小结&#xff1a; 三、编程语言 3.1 程序&#xff1a; 3.2 编程语言发展&a…
阅读更多...
IndexedDB解密：打开Web应用的数据存储之门

IndexedDB解密：打开Web应用的数据存储之门

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 IndexedDB解密&#xff1a;打开Web应用的数据存储之门 前言IndexedDB简介数据库操作数据检索与索引异步操作与事件处理 前言 在Web的世界里&#xff0c;数据就像是一群旅行者&#xff0c;它们来自各个…
阅读更多...
PHPStudy Apache或者MySQL启动以后自动停止

PHPStudy Apache或者MySQL启动以后自动停止

问题 phpstudy小皮面板中的Apache或MySQL启动以后自动停止 正在启动——已启动——已停止 总结&#xff1a;最主要的原因&#xff1a;端口冲突 端口冲突了&#xff0c;已经有其他程序占用了80、3306端口。 也就是说你的电脑上已经有了一个Apache、MySQL并且正在运行。 解决方案…
阅读更多...
「PolarDB-X入门到精通」第六讲：MySQL生态兼容

「PolarDB-X入门到精通」第六讲：MySQL生态兼容

在上一阶段的课程中&#xff0c;已经和大家一起了解了PolarDB分布式数据库的产品架构&#xff0c;并且带领大家一起分别通过PXD、源码编译完成了PolarDB-X 的安装部署。在接下来的课程中&#xff0c;我们将继续带领大家一起学习PolarDB-X的产品特性。 在本期的课程中&#xff0…
阅读更多...
vitis 2020.1 Up date XSA文件后，编译不通过

vitis 2020.1 Up date XSA文件后，编译不通过

原来是可以编译通过的&#xff0c;升级XSA文件后&#xff0c;出现各种问题&#xff0c;pmufw没法编译通过 xpfw_config.h:14:10: fatal error: xparameters.h: No such file or directory Vitis 2020.2 - fatal error: xparameters.h: No such file or directory (xilinx.com)…
阅读更多...
物流EDI：GEFCO EDI 需求分析

物流EDI：GEFCO EDI 需求分析

GEFCO专注于汽车物流领域近70年&#xff0c;是欧洲整车市场的物流供应商&#xff0c;也是欧洲十大领先的运输和物流集团之一。GEFCO的业务遍及六大洲&#xff0c;业务覆盖150个国家&#xff0c;在全球拥有庞大的员工队伍&#xff0c;在全球汽车行业的挑战中茁壮成长。为汽车制造…
阅读更多...
AR人脸美妆SDK解决方案，让妆容更加贴合个人风格

AR人脸美妆SDK解决方案，让妆容更加贴合个人风格

美妆行业正迎来前所未有的变革&#xff0c;为满足企业对高效、精准、创新的美妆技术需求&#xff0c;美摄科技倾力打造了一款企业级AR人脸美妆SDK解决方案&#xff0c;为企业打开美妆领域的新世界大门。 革命性的人脸美妆技术 美摄科技的AR人脸美妆SDK解决方案&#xff0c;不…
阅读更多...
Milvus向量数据库（一）Milvus存储byte[]类型源向量数据

Milvus向量数据库（一）Milvus存储byte[]类型源向量数据

两种路线&#xff1a; 第一种是把byte[]转换为List< float >&#xff0c;然后存储到Milvus的floatVector中第二种是把byte[]转换为ByteBuffer&#xff0c;然后存储到Milvus的BinaryVector中 步骤&#xff1a; 我先用的是第一种&#xff0c;但是在转换float过程中&…
阅读更多...
Python-VBA函数之旅-repr函数

Python-VBA函数之旅-repr函数

目录 一、repr函数的常见应用场景 二、repr函数使用注意事项 三、如何用好repr函数&#xff1f; 1、repr函数&#xff1a; 1-1、Python&#xff1a; 1-2、VBA&#xff1a; 2、推荐阅读&#xff1a; 个人主页&#xff1a;https://blog.csdn.net/ygb_1024?spm1010.2135.…
阅读更多...
mvc区域、Html.RenderAction、Html.RenderPartial、 模板、section

mvc区域、Html.RenderAction、Html.RenderPartial、 模板、section

根据上图 Html.RenderPartial 与 Html.RenderAction 区别 RenderAction 会把对应的视图结果渲染 RenderPartial 会把html视图直接渲染 模板
阅读更多...
十九、分布式数据库MyCat

十九、分布式数据库MyCat

目录 一、概述 1、MyCat是什么&#xff1f; 2、原理&#xff1a; 3、能干什么 1、读写分离 2、数据分片 3、多数据源整合 4、Mycat监控 4、安装部署 1、环境准备 2、安装 3、Mycat配置详解 1、server.xml user 标签 2、schema.xml schema标签&#xff1a; table标签&…
阅读更多...
AI大模型探索之路-训练篇16：大语言模型预训练-微调技术之LoRA

AI大模型探索之路-训练篇16：大语言模型预训练-微调技术之LoRA

系列篇章&#x1f4a5; AI大模型探索之路-训练篇1&#xff1a;大语言模型微调基础认知 AI大模型探索之路-训练篇2&#xff1a;大语言模型预训练基础认知 AI大模型探索之路-训练篇3&#xff1a;大语言模型全景解读 AI大模型探索之路-训练篇4&#xff1a;大语言模型训练数据集概…
阅读更多...
最新闲鱼小众蓝海虚拟资源，单号日入300＋，三天必起店，矩阵放大月入1-2W

最新闲鱼小众蓝海虚拟资源，单号日入300＋，三天必起店，矩阵放大月入1-2W

详情介绍 本项目售卖的虚拟资源非常小众&#xff0c;宅男的最爱&#xff0c;并且市场一片蓝海&#xff01;只需一步手机&#xff0c;随时随地操作项目&#xff0c;流量巨大&#xff0c;安装教程方法操作三天必起店&#xff0c;消息多到回不过来&#xff0c;一天轻松出个大几十单…
阅读更多...
封装Springboot基础框架功能-03

封装Springboot基础框架功能-03

在些模块中汇总了一些web开发常用的配置和功能。 模块源码结构 Restful API常用定义 QueryParam请求参数 Data public class QueryParam {private String key;private String value; }RestfulController实现 RestfulController.java&#xff0c;主要汇总一些常用的restful的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023