【C++】哈希表的开散列、闭散列的代码实现

最新推荐文章于 2024-09-19 13:36:34 发布
最新推荐文章于 2024-09-19 13:36:34 发布
阅读量46 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++ 散列表 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67470729/article/details/131605563
版权

目录

0. 概念

哈希表，又名 散列表

哈希（Hash）是一种方法：将储存元素的 key 和 存储位置 建立映射（关联）关系

建立映射关系的方法具体有：

1. 直接定址法
使用：范围比较集中，每个而数据分配一个唯一位置
2. 除留余数法
适用：范围不集中，分布分散
hashi = key % 10; key 根据存储位置关系模出来的，不同的值映射到了同一个位置（哈希冲突/碰撞）

如何解决哈希冲突问题？

🎯闭散列，又名 开放定址法
在自己的开放空间找下一个位置
a. 线性探测，直接找下一个位置。比较暴力，一些相邻聚集的位置会连续冲突，可能形成“踩踏”
b. 二次探测，模表的长度，冲突后 + i 2。可以缓解线性探测的踩踏
闭散列本质还是一个零和游戏，总不是占了别人的位置
🎯开散列，又名 链地址法 / 开链法 / 拉链法 / 哈希桶
首先对关键码集合，用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

1. 建立 哈希表 用 开放定址法 解决冲突

分析【线性探测】：冲突时找下一个位置

查找

从映射位置开始找，直到空结束

删除

删除后的位置怎么处理？只能单独做一个标识符，给数值和 NULL 都不对

解决：每个存储位置的状态标识【空、存在、删除】

扩容

哈希表在什么情况下扩容？怎么扩？

解决：设置 负载因子 / 载荷因子（反映表存储数据量的程度、百分比），需要控制在0.7~0.8以下

ps：扩容扩的是 size，扩 capacity 没用，没被size 覆盖到的地方 [] 会报非法访问（vector 的特性）。

pps：且会导致映射关系变化，需要单独处理。

namespace OpenAddress
{
	enum State 
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	template<class K, class V>
	class HashTable
	{
	public:

		bool Insert(const pair<K, V>& kv)
		{
			// 去冗
			if (Find(kv.first))
			{
				return false;
			}
			// 负载因子超过0.7就扩容2倍
			//if (_n / _tables.size() >= 0.7)
			//{
			//	// 1. 需要处理空表
			//	// 2. 光扩capacity没法用[]访问，size没变
			//  // 3. 扩完容还需要...重置hash表内数据，要新开一个表，不能在原位置哦
			//	_tables.reserve(_tables.capacity() * 2);	// ×
			//}
			//if (_tables.size() == 0 ||_n * 10 / _tables.size() >= 7)
			//{
			//	size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			//	vector<HashData> newtables(newsize);
			//	// 遍历旧表，重新映射到新表
			//	for (auto& data : _tables)
			//	{
			//		if (data._state == EXIST)
			//		{
			//			// 重新算在新表的位置
			//			// 就是下面的代码复用，逻辑如此，但有没有更简单的方法咧？
			//			size_t i = 1;
			//			size_t index = hashi;
			//			while (newtables[hashi]._state == EXIST)
			//			{
			//				index = hashi + i;
			//				index %= newtables.size();	// 超过表就回到前面
			//				++i;
			//			}
			//			newtables[index]._kv = data._kv;
			//			newtables[index].state = EXIST;
			//		}
			//	}
			//	_tables.swap(newtables);
			//}

			// 扩容
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> newht;
				newht._tables.resize(newsize);		// 用新的hash表对象复用insert
				// 遍历旧表，重新映射到新表
				for (auto& data : _tables)
				{
					newht.Insert(data._kv);
				}
				_tables.swap(newht._tables);
		}
		
			// 映射位置
			size_t hashi = kv.first % _tables.size();	// vector 的特性，模 capacity 后，超出 size 的部分是非法访问！！！自己写还能行，用 vector 就只能模 size
		
			size_t i = 1;
			size_t index = hashi;

			// [线性探测]
			while (_tables[index]._state == EXIST)
			{
				index = hashi + i;
				index %= _tables.size();	// 超过表就回到前面
				++i;
			}

			_tables[index]._kv = kv;
			_tables[index]._state = EXIST;
			_n++;

			return true;
		}
	
		// 注意：表中没有EMPTY的情况！！
		// 插入数据后，在扩容前，删除一 部分数据，在插入数据，并且数据正好占据其他空位，导致表里面，除了存在就是删除
		HashData<K, V>* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				//return false;
				return nullptr;
			}

			size_t hashi = key % _tables.size();

			size_t i = 1;
			size_t index = hashi;

			// [线性探测]
			while (_tables[index]._state != EMPTY)
			{
				if (_tables[index]._state == EXIST
					&& _tables[index]._kv.first == key)
				{
					return &_tables[index];
				}
				index = hashi + i;
				index %= _tables.size();
				++i;
		
				//如果已经找了一圈了，说明表里没有 EMPTY，break 就可以
				if (index == hashi)	
				{
					break;
				}
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;	// 伪删除法：不是正真删除了数据，而是把数据位置标识成删除状态~~
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}

	private:
		/*HashDate* tables;
		size_t _size;
		size_t _capacity;*/			// 用现成的容器很方便呀
	
		vector<HashData<K, V>> _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));

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

		ht.Erase(13);

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

}

2. 建立 哈希表 用 哈希桶 解决冲突

对比开放定址，冲突得到了极大的降低

增删查改的时间复杂度：O(1)
这里是取的平均时间，为啥不取最坏了呢？ 因为有扩容的发生，扩容则重新建立映射关系，最坏情况几乎不会出现
Question：
如果如果，某些桶还是特别长，怎么办
Answer：
  1. 负载因子控制
  2. 单个桶超过一定长度，这个桶改成挂红黑树（结构体 {联合体 {红黑树的指针, 链表的指针}，长度} 解决）
namespace HashBucket
{
	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>
	struct HashFunc
	{
		K operator()(const K& key)
		{
			return key;
		}
	};

	// 特化！！
	template<>
	struct HashFunc<string>
	{
		// BKDR hash
		size_t operator()(const string& s)
		{
			/*return s[0];*/	// 这样写的话，如果首字母相同就是冲突的 ，优化
			size_t hash = 0;
			for (auto ch : s)
			{
				hash += ch;
				hash *= 31;	// 也可以乘131、1313
			}
			return hash;
		}
	};

	template<class K, class V, class Hash = HashFunc<K>>	// Hush：把key转化成可以取模的整形，默认支持整形
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		~HashTable()
		{
			for (auto cur : _tables)
			{
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				cur = nullptr;
			}
		}


		// size_t newsize = GetNextPrime(_tables.size());
		size_t GetNextPrime(size_t prime)
		{
			// SGI 的写法：素数表优化
			const int PRIMECOUNT = 28;
			static const size_t primeList[PRIMECOUNT] =
			{
				53ul, 97ul, 193ul, 389ul, 769ul, 
				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
				1610612741ul, 3221225473ul, 4294967291ul
			};
			size_t i = 0;
			for (; i < PRIMECOUNT; ++i)
			{
				if (primeList[i] > prime)
					return primeList[i];
			}
			return primeList[i];
		}

		Node* Find(const K& key)
		{
			if (_tables.size() == 0)
				return nullptr;

			Hash hash;
			size_t hashi = hash(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 hash;
			size_t hashi = hash(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					// 删
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi] = cur->_next;
					}
					--_n;
					delete cur;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

		// 负载因子越大，冲突的概率越高，查找的效率越低，空间利用率高
		// 负载因子越小，冲突的概率越低，查找的效率越高，空间利用率低
		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;
			// 负载因子 == 1 时扩容
			// 原表的节点重新计算位置，挪动到新表
			Hash hash;
			if (_n == _tables.size())
			{
				//size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				size_t newsize = GetNextPrime(_tables.size());
				vector<Node*> newtables(newsize, nullptr);
				//for (Node*& cur : _tables)
				for (auto& cur : _tables)	// 给&，因为旧表挪下来后还要置空
				{
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(cur->_kv.first) % newtables.size();
						// 头插到新表
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}
				}
				_tables.swap(newtables);
			}

			size_t hashi = hash(kv.first) % _tables.size();
			// 头插就可以
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}

		size_t MaxBucketSize()
		{
			size_t max = 0;
			for (size_t i = 0; i< _tables.size(); ++i)
			{
				auto cur = _tables[i];
				size_t size = 0;
				while (cur)
				{
					++size;
					cur = cur->_next;
				}

				//printf("[%d]->%d\n", i, size);
				if (size > max)
				{
					max = size;
				}
			}
			return max;
		}

	private:
		vector<Node*> _tables;	// 指针数组 
		size_t _n;				// 存储的有效数据个数
	};


	void testHashBucket1()
	{
		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 testHashBucket2()
	{
		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);
	}

	// 测试 BKDR哈希法
	struct HashStr
	{
		// BKDR hash
		size_t operator()(const string& s)
		{
			/*return s[0];*/	// 这样写的话，如果首字母相同就是冲突的 ，优化
			size_t hash = 0;
			for (auto ch : s)
			{
				hash += ch;
				hash *= 31;	// 也可以乘131、1313
			}
			return hash;
		}
	};


	void testHashBucket3()
	{
		//HashTable<string, string, HashStr> ht;
		HashTable<string, string> ht;
		ht.Insert(make_pair("string", "字符串"));
		ht.Insert(make_pair("tree", "树"));
		ht.Insert(make_pair("bucket", "桶"));
		ht.Insert(make_pair("sort", "排序"));
		ht.Insert(make_pair("", "排序"));

		HashStr hashstr;
		cout << hashstr("bacd") << endl;
		cout << hashstr("abcd") << endl;	// 相同...
		cout << hashstr("aadd") << endl;	// 不免这样，也是相同的...
		// BKDR hash 优化
	}


	void testHashBucket4()
	{
		size_t N = 100000;
		HashTable<int, int> ht;

		srand(time(0));
		for (size_t i = 0; i < N; ++i)
		{
			size_t x = rand()+i;
			ht.Insert(make_pair(x, x));
		}

		cout << ht.MaxBucketSize() << endl;
	}
}
TTang-sq
关注
专栏目录
c++哈希（哈希表闭散列线性探测实现）
Dingyuan0的博客
11-09 1048
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？EMPTY , //空标记 EXIST , //存在 DELETE //删除 };};public :// 插入 bool Insert(const pair < K , V > & kv);// 查找 HashDate < K , V > * Find(const K & key);
C++ 哈希表详细讲解（闭散列，开散列）
foodsx的博客
07-12 1213
C++ 哈希表详细讲解（闭散列，开散列）
c++哈希（哈希表开散列实现）
Dingyuan0的博客
11-11 702
文章目录 0. 前言 1. 开散列 1.1 开散列概念 2. 开散列的代码实现 2.0 定义 2.1 插入实现--Insert 2.2 查找实现--Find 2.3 删除实现--Erase 2.4 仿函数 3. 完整代码实现 4. 代码测试并运行结果：
【C++】哈希表-开散列&闭散列
chuxinchangcun的博客
05-17 736
但有些地方也会选择不做此处理,因为随着哈希表中数据的增多,该哈希表的负载因子也会逐渐增大,最终会触发哈希表的增容条件,此时该哈希表当中的数据会全部重新插入到另一个空间更大的哈希表,此时同一个桶当中冲突的数据个数也会减少,增容之后,冲突的数据可能不冲突了！若哈希表的负载因子大于0.7,则重新构造一个新的哈希表,该哈希表的大小为原哈希表的两倍,之后遍历原哈希表,将原哈希表中的数据插入到新哈希表,最后将原哈希表与新哈希表交换即可。
【C++】手撕哈希表的闭散列和开散列
AAlykk的博客
03-24 1453
谈到哈希表，大家都做过这样的题目，统计字符串的字母个数，像这样的题目可以创建一个数组，每个字母采用 a['ch']++ 计入数组中，这样的数组我们称之为哈希表，这种哈希表也是最简单的，如果说为了方便直接调用哈希表，那这个哈希表该如何模拟呢？这个问题也是今天我们所探讨的，手撕哈希表。⭐主体。
C++哈希表的实现
Wzs040810的博客
12-23 5640
C++哈希表的实现
【数据结构】哈希表——闭散列 | 开散列(哈希桶)
weixin_63726869的博客
04-24 2332
介绍了哈希表的概念，常见的哈希函数，解决哈希冲突的两种方法---闭散列以及开散列(哈希桶)，以及它们的代码实现
【C++】哈希 Hash（闭散列、开散列介绍及其实现）
Elena's Blog
11-10 1004
1、闭散列闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把 key 存放到冲突位置中的 “下一个” 空位置中去。核心思想】通过哈希函数计算出这个数据对应的哈希位置，如果该位置出现了哈希冲突，我们就重新探测一个空闲位置，将其插入。那如何重新探测新的位置呢？当我们往散列表中插入数据时，如果某个数据经过散列函数散列之后，存储位置已经被占用了，我们就从当前位置开始，依次往后查找，看是否有空闲位置，直到找到为止。
C++王牌结构hash：哈希表开散列(哈希桶)的实现与应用
2201_75880188的博客
03-30 1270
详细介绍了另一种解决哈希冲突更优的方法，开散列即哈希桶，分析其实现方式及优势，详细介绍并实现了模板、节点构造、插入数据、增容等各个功能
『 C++ - Hash 』闭散列与开散列哈希表详解及其实现 ( 万字 )
小侯宝的博客
02-04 1188
哈希表是一种常用的数据结构,该数据结构往往能存储大量的数据,在C++当中,底层为哈希表的容器最常见的为unordered_xxx系列,例如unordered_map与unordered_set,这两个容器是在C++当中以哈希表为底层的关联式容器,具体的关联式容器的特点参照上篇; 哈希表通过一个叫做哈希函数(Hash Function)的算法,将存储的每个数据项与一个唯一的键值(key)进行绑定;这个函数会将每个键值映射到哈希表中的一个位置,以便对数据进行快速访问;
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地...通过了解哈希表的基本概念、C++ 实现哈希表的实例代码实现、哈希表的实现机制和哈希表的应用场景，我们可以更好地应用哈希表来解决实际问题。
【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）
codewinter的博客
06-26 2787
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log2N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/mul
C++STL-无序容器-哈希表（散列存储）
Iamasleep的博客
04-22 2199
1. 为什么要设计哈希表——查找元素效率高 O(1) 2. 通过什么机制实现的——关键字通过哈希函数O(1)可以直接确定哈希地址，常见的有直接定址法、除留余数法 3. 会产生什么问题——不同的关键字可能会得到相同的哈希地址，称为哈希碰撞 4. 如何解决哈希碰撞——闭散列找空位置（每次向后找1或i^2），或者开散列建哈希桶**
C++ STL中sort函数
weixin_43349440的博客
09-15 405
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
【C++】 —— string的使用
LH__1314的博客
09-16 1420
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
CF C. Nikita and LCM
qq_74190237的博客
09-13 327
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++_map_set详解
2302_77644537的博客
09-16 1025
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C++函数重载
Jason_from_China的博客
09-13 362
概念： C++支持在同一作用域中出现同名函数,但是要求这些同名函数的形参不同,可以是参数个数不同或者 类型不同。这样C++函数调用就表现出了多态行为,使用更灵活。C语言是不支持同一作用域中出现同名函数的。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
最新发布
q2315702359的博客
09-19 738
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
C++实现哈希表：原理与应用实例
哈希表的核心思想是利用散列函数将键值(key)转换为一个数组索引，从而实现常数时间复杂度的查找。以下是哈希表在C++中的一些关键知识点： 1. **哈希表的概念**： - 散列表，或哈希表，是一种以键值对形式存储数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值