哈希的基本概念（开散列和闭散列）（附代码）

已于 2024-01-26 13:24:31 修改
阅读量908 收藏 21
点赞数 20
分类专栏： C++ 数据结构 文章标签： 哈希算法 c++ 数据结构
于 2024-01-25 21:52:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45153969/article/details/135813094
版权

哈希

哈希概念

传统的查找函数，搜索的效率取决于比较的次数。而hash算法：在理想情况下，可以不经过任何比较，一次就能得到要搜索的结果。
存储结构：通过某种（hashFunc）使元素的存储位置与它的关键码之间能够建立一一映射的关系，所以在查找时，通过该映射函数可以很快找到该元素。

  • 插入元素
    根据待插入元素的关键字，以此函数计算出该元素的存储位置并按此位置进行存放。
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当作元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

该方法就是哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表。
大致结构如下图所示：

在这里插入图片描述

哈希冲突

不同的关键词通过相同的哈希函数映射到同一个地址，该现象叫做哈希冲突/哈希碰撞。
如：元素11再插入上图中，就会和元素1产生碰撞。
1和11就是同义词

哈希函数

引起哈希冲突的一个原因可能是：哈希函数设置不合理。
哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应比较简单

常见的哈希函数

  1. 直接定址法（常用）
    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key+B
    优点：简单、均匀
    缺点：需要事先知道关键字的分布情况
    使用场景：适合查找比较小的连续的情况

  2. 除留余数法（常用）
    设散列表中允许的地址数为m，取一个不大于m，但最接近或等于m的质数p作为除数，按照哈希函数：Hash(key) = key % p (p<=m)，将关键码转成哈希地址

  3. 平方取中法
    假设关键字是1234，对它的平方就是1522756,抽取中间3位227作为哈希地址；
    再比如关键字4321，平方是18671041，抽取中间的三位671或者710作为哈希地址。
    平方取中法适合：不知道关键字分布，而位数又不是很大的情况。

  4. 折叠法
    折叠法是将关键字从左到右分割成位数相等的几部分（最后一部分位数可以短些），然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。

  5. 随机数法
    选择一个随机函数，去关键字的随机函数值为它的哈希地址，即H(key) = random(key)，其中random为随机数函数。
    通常应用于关键字不等时采用此法。

  6. 数学分析法
    在这里插入图片描述
    在这里插入图片描述

哈希冲突的解决

解决哈希冲突的两种常见方法是：闭散列和开散列。

闭散列

闭散列（开放定址法）：当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有一个空位置，那么可以把key存放到冲突位置中的“下一个”空位置中去。

  1. 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
  2. 闭散列处理冲突时，不能随便删除物理哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。

闭散列线性探测实现：

	enum class State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct Elem   //数据类型
	{
		pair<K, V> _data;
		State _state=State::EMPTY;
	};

	template<class K, class V>
	class Hashtables
	{
	public:
		bool insert(const pair<K, V>& data)
		{
			if (Find(data.first))
				return false;
			//如果不满足负载，就扩容
			CheckSize();
			
			//求地址
			size_t hashi = data.first % _tables.size(); //不能是capacity，vector天然不支持


			//插入
 			while(_tables[hashi]._state == State::EXIST)
			{
				hashi++;   //线性探测法
				hashi %= _tables.size();
			}
			_tables[hashi]._data = data;
			_tables[hashi]._state = State::EXIST;
			n++;

			return true;
		}

		不方便删除接口
		//pair<K, V>* Find(const K& key)
		//{
		//	if (_tables.size() == 0)
		//	{
		//		return nullptr;
		//	}

		//	size_t hashi = key % _tables.size();
		//	size_t i = 1;
		//	while (_tables[hashi]._state==State::EXIST||_tables[hashi]._state==State::DELETE)  //存在或删除，不影响探测
		//	{
		//		if (_tables[hashi]._state == State::EXIST
		//			&& _tables[hashi]._data.first != key)
		//		{
		//			hashi = hashi + i;
		//			hashi %= _tables.size();
		//			i++;
		//		}
		//		else
		//		{
		//			return &_tables[hashi]._data;
		//		}
		//		if (hashi == key % _tables.size())  //转一圈也没找到
		//		{
		//			return nullptr;
		//		}

		//	}
		//	
		//	return nullptr;
		//}


		Elem<K,V>* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}

			size_t hashi = key % _tables.size();
			size_t i = 1;

			//逻辑有问题
			while (_tables[hashi]._state == State::EXIST || _tables[hashi]._state == State::DELETE)  //存在或删除，不影响探测
			{
				if (_tables[hashi]._state == State::EXIST && _tables[hashi]._data.first == key)
				{
					return &_tables[hashi];

				}
				else    //接着查找
				{
					hashi = hashi + i;
					hashi %= _tables.size();
				}
				if (hashi == key % _tables.size())  //转一圈也没找到，说明全是存在+删除
				{
					return nullptr;
				}

			}

			return nullptr;
		}


		bool erase(const K& key)
		{
			auto it = Find(key);
			if (!it)
			{
				return false;
			}
			//错了！！！！！！！！！！！！！！！
			//it._state == State::DELETE;
			it->_state = State::DELETE;

			n--;   //别忘记计数减一
			return true;
		}

	private:
		void CheckSize()
		{
 			if (_tables.size()==0 ||(double)n / (double)_tables.size() > 0.7)
			{
				int newcapacity = (_tables.size() == 0 ? 10 : _tables.size() * 2);

				vector<Elem<K, V>> newTables(newcapacity);

				//再次重新插入
				for (auto& e : _tables)
				{
					if (e._state == State::EXIST)
					{
						size_t hashi = e._data.first % newTables.size();
						while (newTables[hashi]._state == State::EXIST)
						{
							hashi++;
							hashi %= newTables.size();
						}

						newTables[hashi]._data = e._data;
						newTables[hashi]._state = State::EXIST;
					}
				}

				swap(_tables, newTables);
			}

		}

	private:
		vector<Elem<K, V>> _tables;   //哈希表
		size_t n=0;    //表示插入数据的大小
	};

线性探测优点：实现简单
缺点：一旦发生冲突，所有冲突连在一起，容易产生“堆积”数据。

也可以用二次探测解决即：线性探测由hashi = hashi+i -> hashi + i^2。

研究表明：当表长为质数且装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在装满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装填因子不超过0.5，如果超了，必须考虑增容。

因此闭散列最大的缺陷：空间利用率低，这也是哈希的缺陷。

开散列

开散列又叫链地址法，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各个链表的第一个结点存在哈希表中。

namespace HashBucket
{
	template<class K, class V>
	struct Elem
	{
		Elem(const pair<K, V>& data)
			:_data(data)
			,_next(nullptr)
		{}


		pair<K, V> _data;
		Elem<K, V> *_next;
	};

	template<class K, class V>
	class HashTables
	{
		typedef Elem<K, V> Node;
		typedef pair<K, V> Data;
		//typedef HashTables<K, V> HashTables;
	public:
		bool insert(const Data& data)
		{
			//负载因子过大就扩容
			CheckCapacity();

			//散列地址
			size_t hashi = data.first % _tables.size();

			//直接插入头插
			Node* newNode = new Node(data);
			newNode->_next = _tables[hashi];
			_tables[hashi] = newNode;
			n++;
			return true;

		}

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


		bool erase(const K& key)
		{
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_data.first == key)
				{
					if (!prev)   //prev为空，说明是在表上
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;

		}
	private:
		//扩容有问题，不应该插入一个就扩容，插入一个就扩容！！！！！！！！！！！！
		void CheckCapacity()
		{
			//表为空或者负载因子大于0.7了就扩容
			//if (!_tables.size() || ((n * 10) / (_tables.size() * 10) > 7))
			/*if (!_tables.size() || ((n * 10) / _tables.size() > 7))*/
			if(n==_tables.size())
			{
				size_t newCapacity = (_tables.size() == 0 ? 10 : _tables.size() * 2);
				HashTables* newHashTable = new HashTables;
				newHashTable->_tables.resize(newCapacity);
				
				//将旧表的数据重新映射到新表
				//遍历旧表
				for (auto& e : _tables)
				{
					if (e)  //不空，就有数据
					{
						Node* cur = e;  
						Node* next;   //下一个指针
						while (cur)
						{
							size_t hashi = cur->_data.first % newCapacity;
							next = cur->_next;  //暂存下一个
							cur->_next = newHashTable->_tables[hashi];
							newHashTable->_tables[hashi] = cur;     //头插
							//newHashTable->n++;
							cur = next;

						}
					}
				}
				
				//swap(*newHashTable, *this);
				_tables.swap(newHashTable->_tables);

			}
		}

	private:
		vector<Node*> _tables;
		size_t n = 0;
	};

}

哈希桶的增容问题：
在这里插入图片描述

调整哈希桶的封装接口

数据类型

  1. 不可能所有的数据类型，都是pair的结构。所以，我们应该使Elem结点的值更通用，改用一个模板参数T表示数据类型。
	template<class K, class V>
	struct Elem
	{
		Elem(const pair<K, V>& data)
			:_data(data)
			,_next(nullptr)
		{}


		pair<K, V> _data;
		Elem<K, V> *_next;
	};

修改为：

	//T表示数据类型
	template<class T>
	struct Elem
	{
		Elem(const T& data)
			:_data(data)
			,_next(nullptr)
		{}
		
		T _data;
		Elem<T>* _next;
	};

KeyOfT获取数据（T）的索引（K）

哈希表的模板参数，模板参数修改为K，T，其中使用K进行索引，使用T数据类型，然后使用KeyOfT函数模板来获得数据（T）里面的索引。

代码修改如下：

	//K表示查找值时的索引, T表示数据类型
	template<class K, class T, class KeyOFT>
	class HashTables
	{
		typedef Elem<T> Node;    
		typedef T Data;

	public:
		bool insert(const Data& data)
		{
			KeyOFT kot;
			//负载因子过大就扩容
			CheckCapacity();

			//散列地址
			size_t hashi = kot(data) % _tables.size();

			//直接插入头插
			Node* newNode = new Node(data);
			newNode->_next = _tables[hashi];
			_tables[hashi] = newNode;
			n++;
			return true;

		}

		Node* find(const K& key)
		{
			KeyOFT kot;
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}


		bool erase(const K& key)
		{
			KeyOFT kot;
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (!prev)   //prev为空，说明是在表上
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;

		}
	private:
		//扩容有问题，不应该插入一个就扩容，插入一个就扩容！！！！！！！！！！！！
		void CheckCapacity()
		{
			KeyOFT kot;
			//表为空或者负载因子大于0.7了就扩容
			//if (!_tables.size() || ((n * 10) / (_tables.size() * 10) > 7))
			/*if (!_tables.size() || ((n * 10) / _tables.size() > 7))*/
			if (n == _tables.size())
			{
				size_t newCapacity = (_tables.size() == 0 ? 10 : _tables.size() * 2);
				HashTables* newHashTable = new HashTables;
				newHashTable->_tables.resize(newCapacity);

				//将旧表的数据重新映射到新表
				//遍历旧表
				for (auto& e : _tables)
				{
					if (e)  //不空，就有数据
					{
						Node* cur = e;
						Node* next;   //下一个指针
						while (cur)
						{
							size_t hashi = kot(cur->_data) % newCapacity;
							next = cur->_next;  //暂存下一个
							cur->_next = newHashTable->_tables[hashi];
							newHashTable->_tables[hashi] = cur;     //头插
							//newHashTable->n++;
							cur = next;

						}
					}
				}

				//swap(*newHashTable, *this);
				_tables.swap(newHashTable->_tables);

			}
		}

	private:
		vector<Node*> _tables;
		size_t n = 0;
	};

添加支持多样哈希函数的接口

增加一个FuncHash的模板参数，用来映射key的范围。因为不同的数据有不同的hash映射方法。
该参数还可以解决，data不是整数的问题，比如string，我们可以提供特定的函数来支持string进行hash。

namespace HashBucket
{
	//T表示数据类型
	template<class T>
	struct Elem
	{
		Elem(const T& data)
			:_data(data)
			, _next(nullptr)
		{}


		T _data;
		Elem<T>* _next;
	};

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

	//特化版本
	template<>
	struct Hash<string>
	{
		//BKDR哈希*31
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto e : s)
			{
				hash += e;
				hash *= 31;
			}
			return hash;
		}
	};


	//K表示查找值时的索引, T表示数据类型,KeyOFT获取T的索引K，HashFunc计算Hash的函数
	template<class K, class T, class KeyOFT, class HashFunc = Hash<K>>
	class HashTables
	{
		typedef Elem<T> Node;    
		typedef T Data;

	public:
		bool insert(const Data& data)
		{
			HashFunc hash;
			KeyOFT kot;
			//负载因子过大就扩容
			CheckCapacity();

			//散列地址
			size_t hashi = hash(kot(data)) % _tables.size();

			//直接插入头插
			Node* newNode = new Node(data);
			newNode->_next = _tables[hashi];
			_tables[hashi] = newNode;
			n++;
			return true;

		}

		Node* find(const K& key)
		{
			HashFunc hash;
			KeyOFT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}


		bool erase(const K& key)
		{
			HashFunc hash;
			KeyOFT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (!prev)   //prev为空，说明是在表上
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;

		}
	private:
		//扩容有问题，不应该插入一个就扩容，插入一个就扩容！！！！！！！！！！！！
		void CheckCapacity()
		{
			KeyOFT kot;
			HashFunc hash;
			//表为空或者负载因子大于0.7了就扩容
			//if (!_tables.size() || ((n * 10) / (_tables.size() * 10) > 7))
			/*if (!_tables.size() || ((n * 10) / _tables.size() > 7))*/
			if (n == _tables.size())
			{
				size_t newCapacity = (_tables.size() == 0 ? 10 : _tables.size() * 2);
				HashTables* newHashTable = new HashTables;
				newHashTable->_tables.resize(newCapacity);

				//将旧表的数据重新映射到新表
				//遍历旧表
				for (auto& e : _tables)
				{
					if (e)  //不空，就有数据
					{
						Node* cur = e;
						Node* next;   //下一个指针
						while (cur)
						{
							size_t hashi = hash(kot(cur->_data)) % newCapacity;
							next = cur->_next;  //暂存下一个
							cur->_next = newHashTable->_tables[hashi];
							newHashTable->_tables[hashi] = cur;     //头插
							//newHashTable->n++;
							cur = next;

						}
					}
				}

				//swap(*newHashTable, *this);
				_tables.swap(newHashTable->_tables);

			}
		}

	private:
		vector<Node*> _tables;
		size_t n = 0;
	};
羊羊羊i
关注
  • 20
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希 ：哈希冲突、负载因子、哈希函数、哈希表、哈希桶
Jormungand_V的博客
08-29 2701
文章目录哈希哈希（散列）函数 哈希 哈希（散列）是一种数据结构，通过散列算法将元素值转换为散列值进行存储。使得元素存储的位置与元素本身建立起了映射关系，如果要查、改数据，就可以直接到对应的位置去，使得时间复杂度达到了 O(1)。 哈希（散列）函数 哈希函数就是建立起元素与其存储位置的映射关系。 对于哈希函数来说，必须具有以下特点; 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0 到m-1之间 哈希函数计算出来的地址能均匀分布在整个空间中（防止产生密集的哈希冲突
各种哈希函数及代码
liwei的专栏
12-22 3977
昨天学了哈希表的使用，并且做了些题，对哈希比较了解了。今天就来做一下哈希算法的题，以便难题也会做……这个是转载别人的，因为哈希的实质就是确定每一组数据的地址，而怎么样确定地址才不会重复呢？如果重复的话，那查询的时候就会出错了；如果不想出错，那么哈希的结构体也可以加个链表，但是在有些题面前，不必这么用。所以就有了哈希函数，来最大的唯一的来确定每组数据的地址…… 常用的字符串Hash函数还有
【C++】-- 哈希（上万字详细配图配代码从执行一步步讲解）
weixin_64609308的博客
01-02 938
【C++】-- 哈希（上万字详细配图配代码从执行一步步讲解）详细讲解哈希处理数据查找的一些系列操作的亮眼操作之处。从数据结构的计数排序到哈希的哈希冲突、哈希冲突的解决：开散列、闭散列。
数据结构之哈希（C++实现）
CHAKMING1的博客
01-20 1650
介绍了哈希的基本概念，介绍了开散列和闭散列的概念和对应的C++代码实现方式。在哈希的基础上拓展并实现了位图和布隆过滤器。
数据结构--哈希(Hash)和代码实现(详解)
m0_64263546的博客
05-05 9319
哈希一.哈希的概念二.哈希函数三.哈希冲突四.哈希的代码实现(1)哈希的创建(2)哈希的初始化(3)哈希函数(4)哈希的元素添加(5)哈希的显示(6)哈希的查找(7)哈希的删除五.总代码 一.哈希的概念 线性表、树结构的查找方式都是以关键字的比较为基础, 查找效率比较低。如果能在元素的存储位置和其关键字之间建立某种联系,那么在进行查找时,可以通过很少的比较找到该元素,这个就是哈希的思想 二.哈希函数 哈希函数可以将一个元素的访问过程更加迅速更加有效,通过哈希函数，数据元素可以很快被定位。这篇文章将采用
c# 加密和解密相关代码
09-06
inputStream：要计算其哈希代码的输入。 返回值：计算所得的哈希代码。 图19.2 使用MD5 算法加密数据 第19章 加密与解密技术 831 计算指定字节数组的指定区域的哈希值，语法格式如下： public byte[] Compute...
实验5----哈希表实验报告.doc
03-10
根据设定的哈希函数f(key)和处理冲突的方法将一组关键字映像到一个有限的连续的地 址集（区间）上，并以关键字在地址集中的"像"作为记录在表中的存储位置，这种表便 称为哈希表，这一映像过程称为哈希造表或散列，...
imagehash：PHP PHP的感知图像哈希
02-25
与诸如MD5和SHA1的加密哈希函数相比，感知哈希是一个不同的概念。 使用加密哈希时，哈希值是随机的。 用于生成哈希的数据的行为类似于随机种子，因此相同的数据将生成相同的结果，但是不同的数据将生成不同的结果。...
功能图及其在迭代哈希构造的一般攻击中的应用
03-15
我们提供了有关密码散列结构的一般攻击的调查，包括基于散列的消息身份验证代码和散列组合器。我们研究了涉及多次迭代评估相同映射的攻击。 随机映射的功能图还涉及迭代评估映射。 这些攻击实质上是利用功能图的属性...
dna2way:核苷酸序列的双向哈希函数。 为正向或反向补码生成相同的输出
06-26
DNA2Way DNA 的哈希函数，可为正向偏置或反向互补生成相同的输出。 作者：凯瑟尔·加维；... 也就是说，DNA 是一个双向代码，它具有不同代码的“正向”和“反向互补”链（这通常是主观的），但在现实世界中，
哈希函数代码
11-03
大学课程、数据结构、C代码、设定哈希函数 H(key) = key MOD 11 ( 表长=11 )，输入一组关键字序列，根据线性探测再散列解决冲突的方法建立哈希表的存储结构，显示哈希表，任意输入关键字，判断是否在哈希表中。
常用的hash函数代码
03-12
Hash函数代码，便于结合原理与实践。你可以下载后学习，更希望你能分享出更好的代码
哈希代码实现
10-30
哈希表学习时敲的代码，很全
hash函数 c程序
04-21
该函数可以在输入Hash_QueryParameters.txt文件下，每行为一个数据（可以随便写）输入哈希表中，可以查找，删除，插入等操作
哈希算法的实现
12-11
数据结构作业四,对哈希
数据结构之哈希表以及常用哈希的算法表达（含全部代码）
勾栏听曲_0的博客
09-03 2923
哈希表也叫散列表，哈希表是一种数据结构，它提供了快速的插入操作和查找操作，无论哈希表总中有多少条数据，在有足够优秀的哈希算法时，插入和查找的时间复杂度都是为O(1)。 散列表 （ Hash table ），是根据键（Key）而直接访问在记忆体储存位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表 。表中存储的是一个地址，我们通过键值计算出来的哈希值得到这个地址，再取这个地址中的数据即可
几种常见哈希函数代码实现
ceceGao_的专栏
02-14 4399
几种常见哈希函数的C代码实现 哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。——百度百科 在网上各处搜集了一些
哈希（开散列、闭散列）-位图-布隆过滤器-哈希切分
weixin_58843717的博客
12-06 690
哈希实现unordered_map unoredered_set的底层原理，哈希中的开散列、闭散列，位图，布隆过滤器，哈希切分
密码学小知识(6)：变色龙哈希函数（Chameleon Hash）
热门推荐
cryptocxf的博客
10-10 1万+
本篇博文将介绍变色龙哈希函数。 在介绍变色龙哈希函数之前，我们先简单回顾一下经典的哈希函数，这样就能对比它们之间的差别。 一、哈希函数 哈希函数Hash()Hash( )Hash()是密码学中经常用到的一个函数（记住它并不是加密技术，独立于非对称加密和对称加密之外的函数），任意大小的输入消息mmm经过哈希函数H()H( )H()映射成一个固定长度的输出值hhh，通常称hhh为哈希值或哈希摘要，即 h=H(m)h=H(m)h=H(m)具有三个特别重要的性质： 1）单向性：从输入到输出的计算过程较为容易，而由
解决哈希冲突的开散列方法
最新发布
05-23
开散列的基本思想是将哈希表中的每个位置都指向一个链表或者其他数据结构，如果发生哈希冲突，就将冲突的元素加入到对应位置的链表中。 开散列的实现过程如下： 1. 创建一个大小为n的数组，每个元素都是一个链表头...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值