【C++进阶】哈希表的实现

最新推荐文章于 2025-05-13 23:18:04 发布
原创 最新推荐文章于 2025-05-13 23:18:04 发布 · 1k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c++ #散列表 #数据结构
本文介绍了哈希表的基本概念，通过线性探测、二次探测和链式哈希表的实现详细阐述了哈希表的插入、查找和删除操作。并提供了C++实现的代码示例。

文章目录

哈希表的概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
这篇博客我们简单的介绍一下哈希表，重点是哈希表的实现，下次的博客会为大家详细的介绍一下哈希表。

线性探测哈希表的实现

哈希表的结构

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

哈希表数据的结构

在这里插入图片描述

插入

在这里插入图片描述

查找

在这里插入图片描述

删除

在这里插入图片描述

二次探测哈希表的实现

哈希表的结构

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

哈希表数据的结构

在这里插入图片描述

插入

在这里插入图片描述

查找

在这里插入图片描述

删除

在这里插入图片描述

链式哈希表(哈希桶)的实现

哈希表的结构

在这里插入图片描述

哈希表数据的结构

在这里插入图片描述

插入

在这里插入图片描述

查找

在这里插入图片描述

删除

在这里插入图片描述

整体的代码

#pragma once
#include <vector>
template<class K>
struct Hash
{
	size_t operator()(const K& key)
	{
		return key;
	}
};
template<>
struct Hash<string>
{
	size_t operator()(const string& s)
	{
		size_t value = 0;
		for (auto& ch : s)
		{
			value += ch;
		}
		return value;
	}
};
namespace LinearDetectionHash
{
	enum status
	{
		EMPTY,//空
		EXIST,//存在
		DELETE//删除
	};
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;//要存的值
		status _status = EMPTY;//状态
	};
	
	template<class K,class V,class HashFunc = Hash<K>>
	class HashTable
	{
		
	public:
		HashTable()
		{}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_status = DELETE;
				_size--;
				return true;
				
			}
			else
			{
				return false;
			}
		}
		HashData<K, V>* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t index = hf(key) % _tables.size();
			while (_tables[index]._status == EXIST)
			{
				if (_tables[index]._kv.first == key && _tables[index]._status == EXIST)
				{
					return &_tables[index];
				}
				index++;
			}

			return nullptr;
		}
		bool Insert(const pair<K,V>& kv)
		{
			HashData<K, V>* ret = Find(kv.first);
			HashFunc hf;
			if (ret)
			{
				return false;
			}
			if (_tables.size() == 0 || _size*10 / _tables.size() > 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : 2 * _tables.size();
				HashTable<K,V> newHT;
				newHT._tables.resize(newsize);
				for (int i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._status == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);

			}
			size_t index = hf(kv.first) % _tables.size();
			while (_tables[index]._status == EXIST)
			{
				index++;
				index %= _tables.size();
			}

			_tables[index]._kv = kv;
			_tables[index]._status = EXIST;
			_size++;
			return true;

		}
	private:
		vector<HashData<K,V>> _tables;
		size_t _size = 0;
	};

	void TestHashTable1()
	{
		HashTable<int, int> kv;
		kv.Insert(make_pair(1, 1));
		kv.Insert(make_pair(2, 2));
		kv.Insert(make_pair(3, 3));
		kv.Insert(make_pair(4, 4));
		kv.Insert(make_pair(14, 14));
		kv.Insert(make_pair(24, 24));
		kv.Insert(make_pair(34, 34));
		kv.Insert(make_pair(11, 11));
		kv.Insert(make_pair(21, 21));
		kv.Insert(make_pair(31, 31));
		kv.Insert(make_pair(32, 32));

		/*cout << kv.Find(1) << endl;
		cout << kv.Find(3) << endl;
		cout << kv.Find(14) << endl;
		cout << kv.Find(32) << endl;
		cout << kv.Find(33) << endl;*/
		
	}
	void TestHashTable2()
	{
		HashTable<string, string> kv;
		kv.Insert(make_pair("sort", "排序"));
		kv.Insert(make_pair("soda", "苏打水"));
		kv.Erase("sort");
		cout << kv.Find("sort") << endl;
		cout << kv.Find("test") << endl;

	}
}
namespace SecondaryDetectionHash
{
	enum status
	{
		EMPTY,
		EXIST,
		DELETE
	};
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		status _status = EMPTY;
	};

	template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{

	public:
		HashTable()
		{}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_status = DELETE;
				_size--;
				return true;

			}
			else
			{
				return false;
			}
		}
		HashData<K, V>* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t i = 0;
			size_t index = hf(key) % _tables.size();
			while (_tables[index]._status == EXIST)
			{
				if (_tables[index]._kv.first == key && _tables[index]._status == EXIST)
				{
					return &_tables[index];
				}
				i++;
				index += i*i;
				index %= _tables.size();
			}

			return nullptr;
		}
		bool Insert(const pair<K, V>& kv)
		{
			HashData<K, V>* ret = Find(kv.first);
			HashFunc hf;
			if (ret)
			{
				return false;
			}
			if (_tables.size() == 0 || _size * 10 / _tables.size() > 7)
			{
				size_t newsize = _tables.size() == 0 ? 10 : 2 * _tables.size();
				HashTable<K, V> newHT;
				newHT._tables.resize(newsize);
				for (int i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._status == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);

			}
			size_t i = 0;
			size_t index = hf(kv.first) % _tables.size();
			while (_tables[index]._status == EXIST)
			{
				i++;
				index += i * i;
				index %= _tables.size();
			}

			_tables[index]._kv = kv;
			_tables[index]._status = EXIST;
			_size++;
			return true;

		}
	private:
		vector<HashData<K, V>> _tables;
		size_t _size = 0;
	};

	void TestHashTable1()
	{
		HashTable<int, int> kv;
		kv.Insert(make_pair(1, 1));
		kv.Insert(make_pair(2, 2));
		kv.Insert(make_pair(3, 3));
		kv.Insert(make_pair(4, 4));
		kv.Insert(make_pair(14, 14));
		kv.Insert(make_pair(24, 24));
		kv.Insert(make_pair(34, 34));
		kv.Insert(make_pair(11, 11));
		kv.Insert(make_pair(21, 21));
		kv.Insert(make_pair(31, 31));
		kv.Insert(make_pair(32, 32));

		cout << kv.Find(1) << endl;
		cout << kv.Find(3) << endl;
		cout << kv.Find(14) << endl;
		cout << kv.Find(32) << endl;
		cout << kv.Find(33) << endl;

	}
	void TestHashTable2()
	{
		HashTable<string, string> kv;
		kv.Insert(make_pair("sort", "排序"));
		kv.Insert(make_pair("soda", "苏打水"));
		//kv.Erase("sort");
		cout << kv.Find("sort") << endl;
		cout << kv.Find("test") << endl;

	}
}
namespace LinkHash
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* next;
		HashNode(const pair<K,V>& kv)
			:_kv(kv)
			,next(nullptr)
		{}

	};
	template<class K, class V,class HashFunc = Hash<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		bool Erase(const K& key)
		{
			if (_size == 0)
			{
				return false;
			}
			HashFunc hf;
			size_t index = hf(key) % _tables.size();
			Node* cur = _tables[index];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					Node* next = cur->next;
					
					if(prev)
						prev->next = next;
					else
						_tables[index] = next;

					delete cur;
					cur = nullptr;
					_size--;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
		Node* Find(const K& key)
		{
			if (_size == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t index = hf(key) % _tables.size();
			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				else
				{
					cur = cur->next;
				}
			}
			return nullptr;
		}
		bool Insert(const pair<K, V>& kv)
		{
			Node* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			if (_tables.size() == 0 || _size*10 / _tables.size() == 10)
			{
				size_t newsize = _tables.size() == 0 ? 10 : 2 * _tables.size();
				HashTable<K, V> newHT;
				newHT._tables.resize(newsize);
				HashFunc hf;
				for (int i = 0; i < _tables.size(); i++)
				{
						Node* cur = _tables[i];
						while (cur)
						{
							Node* next = cur->next;
							size_t index = hf(cur->_kv.first) % newHT._tables.size();
							if (newHT._tables[index])
							{
								Node* next = newHT._tables[index];
								newHT._tables[index] = cur;
								cur->next = next;
							}
							else
							{
								newHT._tables[index] = cur;
								newHT._tables[index]->next = nullptr;;
							}
							newHT._size++;
							cur = next;
						}
						_tables[i] = nullptr;	
				}
				_tables.swap(newHT._tables);
			}
			HashFunc hf;
			Node* cur = new Node(kv);
			size_t index = hf(kv.first) % _tables.size();
			if (_tables[index])
			{
				Node* next = _tables[index];
				_tables[index] = cur;
				cur->next = next;
			}
			else
			{
				_tables[index] = cur;
			}
			_size++;
			return true;
		}
	private:
		vector<Node*> _tables;
		size_t _size = 0;
	};
	void TestHashTable1()
	{
		HashTable<int, int> kv;
		kv.Insert(make_pair(1, 1));
		kv.Insert(make_pair(2, 2));
		kv.Insert(make_pair(3, 3));
		kv.Insert(make_pair(4, 4));
		kv.Insert(make_pair(14, 14));
		kv.Insert(make_pair(24, 24));
		kv.Insert(make_pair(34, 34));
		kv.Insert(make_pair(11, 11));
		kv.Insert(make_pair(21, 21));
		kv.Insert(make_pair(31, 31));
		kv.Insert(make_pair(32, 32));
		kv.Insert(make_pair(10, 10));

		cout << kv.Find(1) << endl;
		cout << kv.Find(100) << endl;


	}
	void TestHashTable2()
	{
		HashTable<int, int> kv;
		kv.Insert(make_pair(1, 1));
		kv.Insert(make_pair(11, 11));
		kv.Insert(make_pair(2, 2));
		cout << kv.Erase(4) << endl;
		cout << kv.Erase(11) << endl;
		cout << kv.Erase(2) << endl;
		cout << kv.Erase(1) << endl;


	}
}
C++ 哈希表
Han同学
02-26 5204
C++哈希表
【C++】哈希表
m0_63852285的博客
05-07 2194
散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。
【数据结构篇C++实现】- 哈希表
陈七的博客，学习知识分享，期待与大家的交流
03-28 4228
有关散列表（哈希表）数据结构的知识点总结
c++进阶——哈希表的实现
最新发布
2301_79705195的博客
05-13 1109
本文介绍了哈希表的基本概念及其实现方式。哈希表通过哈希函数将关键字映射到存储位置，以实现快速查找和插入。C++ STL库中的unordered_set和unordered_map基于哈希表实现，与基于红黑树的set和map相比，哈希表在搜索和插入效率上更高，但无序。哈希表的关键在于将关键字转化为整型并通过哈希函数映射到表中，这可能导致哈希冲突。解决冲突的常用方法有开放定址法和链地址法。开放定址法通过线性探测等方式解决冲突，而链地址法则通过链表或红黑树处理冲突。哈希函数的选取对哈希表的性能至关重要，常见的哈希
C++进阶——哈希表的实现
博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴
03-25 1258
乘法散列法对哈希表大小 M 是没有要求的，假设 M 为 1024，key 为 1234，A = 0.6180339887，A * key = 762.6539420558，取小数部分为 0.6539420558，M × ((A × key) % 1.0) = 0.6539420558 * 1024 = 669.6366651392，那么 h(1234) = 669。假设 P=17，M=6，a=3，b=4，则 h_34(8) = ((3 × 8 + 4) % 17) % 6 = 5。
C++进阶：哈希表实现
2301_81699364的博客
11-21 1307
当key是string/Date等类型时，key不能取模，那么我们需要给HashTable增加一个仿函数，这个仿函数支持把key转换成一个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现⼀个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。如果是2^x ，那么key%2^x本质相当于保留key的后X位，那么后x位相同的值，计算出的哈希值都是⼀样的，就冲突了。
【C++进阶】哈希表的介绍及实现
2301_78022459的博客
10-17 1491
【C++进阶】哈希表的介绍及实现
C++实现哈希表。
TPON的博客
11-17 6908
C++模拟实现哈希表
『数据结构』哈希表
叄拾叄画生
08-05 7249
什么是哈希？哈希冲突。哈希函数。哈希冲突解决方法。闭散列（线性探测、二次探测）。开散列（哈希桶）、开散列模拟实现（C++和Java）。
C++实现哈希表
Ly的博客
05-28 3243
本文主要是对哈希表这种数据结构进行介绍。含义是根据存储的值和存储的位置建立映射关系从而快速检索查找存储的数据，哈希表是一种非常高效的数据结构。本文会用C++介绍哈希表的相关实现。
【C++进阶】九、哈希表
枫叶先生的博客
03-19 2122
哈希概念|哈希冲突|哈希函数|哈希冲突解决|哈希表的闭散列实现|哈希表的开散列实现（哈希桶）详解
C++ 数据结构与算法（五）（哈希表）
chenyfan_blog
02-25 6465
哈希表 LeetCode 代码随想录
【C++进阶】哈希表详解
m0_67077469的博客
03-21 2821
哈希表详解
C++代码中使用哈希表
树欲静静风不止止的博客
08-30 4345
C++代码中如何使用哈希表
unorderd_map和unordered_set模拟实现
qq_74081037的博客
02-15 1579
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位 置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法 为：hashi = ($H_0$ + i^2 )% m, 或者：hashi = ($H_0$ - i^2 )% m。开散列增容 ： 桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可 能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容。哈希函数应该比较简单。
C++：【数据结构】哈希表
qq_73176808的博客
05-30 2494
哈希表（hash table）又叫散列表，是一种很实用的数据结构。首先来看一下百度给出的定义：散列表，是。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。通俗一点来说，就是我们有一堆值，他们的范围很大，但是又很分散，直接存储本身的话会非常占地方，所以我们就把它，这样不但节省了空间，而且还方便查找。
C++哈希表的实现
Wzs040810的博客
12-23 6533
C++哈希表的实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值