哈希表——线性探测、二次探测

最新推荐文章于 2023-02-08 23:15:00 发布
原创 最新推荐文章于 2023-02-08 23:15:00 发布 · 2.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了散列表的基本概念，包括散列函数、散列冲突及其处理方法，并详细展示了使用C++实现散列表的过程，包括线性探测和二次探测两种解决冲突的策略。

线性表，二叉搜索树、AVL树、红黑树B树中，元素在存储结构中的位置与元素的关键码之间不存在直接的对应关系。在数据结构中搜索一个元素需要进行一系列的关键码比较。搜索的效率取决于搜索过程中比较的次数。

理想的搜索方法是可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，使元素的存储位置与它的关键码之间建立一个确定的对应函数关系Hash()，那么每个元素关键码与结构中的一个唯一的存储位置相对应：

Address = Hash(Key)

在插入时，根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。在搜索时，对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。该方式即散列方法(Hash Method)，在散列方法中使用的转换函数叫着散列函数(Hash function)，构造出来的结构叫散列表(Hash Table)。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

 哈希冲突(哈希碰撞）

对于两个数据元素的关键字Ki和Kj(i != j)，有Ki ！= Kj(i != j)，但HashFun(Ki)== HashFun(Kj)，将该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”，由同义词引起的冲突称为同义词冲突。

在哈希表中，哈希冲突越多就越不稳定。

散列冲突处理方法

任何一种散列函数也不能避免产生冲突，因此选择好的解决冲突溢出的方法十分重要。为了减少冲突必须对散列表加以改造。

闭散列法

闭散列也叫开地址法。设散列表的编址为0到m-1，当添加关键码key时通过散列函数hash(key)计算key的存放位置，但在存放时发现这个桶已经被另一个keyx占据了，即发生哈希冲突。如果表未被装满，表示在给定的范围内必然还有空位置，则可以把key存放到表中“下一个”空位中。

简而言之：一旦发生冲突，就去寻找下一个空的散列表地址，只要散列表足够大，空的散列地址总能找到。

下面是我实现的线性探测和二次探测的代码：
#pragma once
#include<vector>
#include<iostream>
#include<string>

namespace OPEN
{
	using namespace std;

	enum State
	{
		EXIST, Delete, EMPTY
	};



	template<class K, class V >
	struct HashNode
	{
		pair<K, V> _kv;
		State _state;//标记一个位置的状态

		HashNode()
			:_state(EMPTY)
		{}
	};

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

	};

	template<>
	struct __HashFunc<string>
	{
		static size_t BRDRHash(const char* str)
		{
			unsigned int seed = 131;
			unsigned int hash = 0;
			while (*str)
			{
				hash = hash* seed + (*str++);
			}
			return (hash & 0x7FFFFFFF);
		}
		size_t operator()(const string& key)
		{
			return   BRDRHash(key.c_str());
		}

	};
	/*
	struct __HashFuncString
	{
	static size_t BRDRHash(const char* str)
	{
	unsigned int seed = 131;
	unsigned int hash = 0;
	while (*str)
	{
	hash = hash* seed + (*str++);
	}
	return (hash & 0x7FFFFFFF);
	}
	size_t operator()(const string& key)
	{
	return   BRDRHash(key.c_str());
	}
	};
	*/

	template<class K, class V, class HashFunc = __HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
			:_n(0)
		{}

		//线性探测
		bool Insert(pair<K, V>& kv)
		{
			CheckCapacity();
			size_t index = _HashFunc(kv.first);
			while (_tables[index]._state == EXIST)
			{
				if (_tables[index]._kv.first == kv.first)
				{
					return false;//检查冗余，表示这个地方已经有数据了
				}
				++index;
				if (index = _tables.size())//走到了数组的最后,折回到数组的头重新往后
				{
					index = 0;
				}
			}
			_tables[index]._kv = kv;
			_tables[index]._state = EXIST;
			++_n;

			return true;
		}

		//二次探测
		bool Insert2(pair<K, V>& kv)
		{
			CheckCapacity();
			size_t i = 1;
			size_t index = _HashFunc(kv.first);
			while (_tables[index]._state == EXIST)
			{
				if (_tables[index]._kv.first == kv.first)
				{
					return false;//检查冗余，表示这个地方已经有数据了
				}

				index += i*i;
				index = index % _tables.size();//走到了数组的最后,折回到数组的头重新往后
				++i;
			}
			_tables[index]._kv = kv;
			_tables[index]._state = EXIST;
			++_n;

			return true;
		}


		HashNode<K, V>* Find(const K& key)
		{
			size_t index = _HashFunc(key);
			while (_tables[index]._state != EMPTY)
			{
				if (_tables[index]._kv.first == key)
				{
					if (_tables[index]._state == EXIST)
					{
						return &_tables[index];
					}
				}
				++index;
				if (index == _tables.size())
				{
					index = 0;
				}
			}
			return NULL;
		}


		bool Remove(const K& key)
		{
			HashNode<K, V>* node = Find(key);
			if (node)
			{
				node->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}

		size_t Size()
		{
			return _n;
		}

		size_t Capacity()
		{
			return _tables.size();
		}

		/*
		bool Insert2(pair<K, V>& kv)
		{
		size_t index = _HashFunc2(kv.first);
		while (_tables[index]._state == EXIST)
		{
		++index;
		if (index = _tables.size())
		{
		index = 0;
		}
		_tables[index]._kv = kv;
		_tables[index]._states = EXIST;
		++_n;
		}
		}
		*/


	private:
		//pair<K, V>* _tables;//数组
		//size_t _size;
		//size_t _capacity;//增容


		vector<HashNode<K, V>> _tables;
		size_t _n;//实际存了多少个数

		size_t GetNextPrime(size_t value)
		{
			/*const int _PrimeSize = 28;*/
			/*static const unsigned long _PrimeList[_PrimeSize] =
			{
				53ul, 97ul, 193ul
			};*/
			const int _PrimeSize = 28;
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				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
			};

			for (size_t i = 0; i < _PrimeSize; i++)
			{
				if (_PrimeList[i]>value)
				{
					return _PrimeList[i];
				}
			}
			return _PrimeList[_PrimeSize - 1];
		}


		void CheckCapacity()
		{
			if (_tables.empty())
			{
				_tables.resize(GetNextPrime(0));
				return;
			}
			if (_n * 10 / _tables.size() == 7)  //容量超过70%的时候容易发生哈希冲突,开始增容
			{
				size_t newsize = GetNextPrime(_tables.size());
				HashTable<K, V, HashFunc> newHT;
				newHT._tables.resize(newsize);

				for (size_t i = 0; i < _tables.size(); ++i)
				{
					if (_tables[i]._state == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
		}



		size_t _HashFunc(const K& key)//作用？？？
		{
			HashFunc hash;
			return  hash(key) % _tables.size();
		}



	};


	void Test()
	{
		HashTable<int, int> ht1;
		ht1.Insert(make_pair(1, 0));
		ht1.Insert(make_pair(2, 0));
		ht1.Insert(make_pair(3, 0));
		ht1.Insert(make_pair(4, 0));

		HashTable<int, int> ht2(ht1);

		for (int i = 0; i < 54; i++)
		{
			ht1.Insert(make_pair(i, i));
		}

		//HashTable<string, string,__HashFunc<string>> dict;
		HashTable<string, string> dict;
		dict.Insert(make_pair(string("left"), string("左边")));
		dict.Insert(make_pair(string("right"), string("右边")));
		dict.Insert(make_pair(string("mid"), string("中间")));

		HashNode<string, string>* ret = dict.Find("left");
		cout << ret->_kv.second << endl;
	}
}
 

namespace BUCKET
{
	using namespace std;

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

		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(NULL)
		{}
	};


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

	};


	template<>
	struct __HashFunc<string>
	{
		static size_t BRDRHash(const char* str)
		{
			unsigned int seed = 131;
			unsigned int hash = 0;
			while (*str)
			{
				hash = hash* seed + (*str++);
			}
			return (hash & 0x7FFFFFFF);
		}
		size_t operator()(const string& key)
		{
			return   BRDRHash(key.c_str());
		}

	};

	/*template<class K,class V,class HashFunc == __HashFunc<K>>
	struct HashTableIterator
	{
		typedef HashNode<K, V> Node;
		typedef HashTableIterator<K, V, HashFunc> Self;

	    Node* _node;	 
		HashTable<K, V, HashFunc>* _ht;

		Hash

		pair<K,V>& operator*()
		{
			return _node->_kv;
		}

		pair<K, V>* operator->()
		{
			return &opertaor*();
		}

		Self& operator++
		{ 
			//1.如果当前桶没走完，继续走
			//2.如果当前桶走完了，找下一个不为空的桶
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				HashFunc hf;
				size_t index = hf(_node->_kv.first);
				_node = NULL;
				for (size_t i = index; i < _ht._tables.size(); i++)
				{
					if (_ht->_tables[i])
					{
						_node = _ht->tables[i];
						break;
					}
				}
			}
			return *this;
		}




		Self& operator--()
		{

		}
	};
	*/
	
	template<class K, class V>
	class HashTable
	{
		typedef HashNode<K, V> Node;

	public:
		HashTable()
			:_n(0)
		{}


		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = NULL;
			}
		}


		bool Insert(const pair<K, V>& kv)
		{
			_CheckCapacity();
			size_t index = _HashFunc(kv.first, _tables.size());
			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_kv.first == kv.first)
				{
					return true;
				}
				cur = cur->_next;
			}
			//头插
			Node* tmp = new Node(kv);
			tmp->_next = _tables[index];//??
			_tables[index] = tmp;//??

			++_n;

			return true;
		}


		Node* Find(const K& key)
		{
			size_t index = _HashFunc(key, _tables.size());
			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return NULL;
		}


		bool Remove(const K& key)
		{
			size_t index = _HashFunc(key, _tables.size());
			Node* prev = NULL;
			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == NULL)
					{
						//头删
						_tables[index] = cur->_next;
					}
					else
					{
						//非头删
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}



	private:
		vector<Node*> _tables;
		size_t _n;


		size_t _HashFunc(const K& key, size_t size)
		{
			return key % _tables.size(); 
		};



		void _CheckCapacity()
		{
			if (_tables.size() == _n)
			{
				size_t newsize = GetNextPrime(_tables.size());
 
				vector<Node*> newTables;
				newTables.resize(newsize);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t index = _HashFunc(cur->_kv.first, _tables.size());

						cur->_next = newTables[index];
						newTables[index] = cur;

						cur = next;
					}
					_tables[i] = NULL;
				}
				_tables.swap(newTables);
			}
		}

		size_t GetNextPrime(size_t value)
		{
			/*const int _PrimeSize = 28;
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				53ul, 97ul, 193ul
			};*/
			const int _PrimeSize = 28;
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				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
			};

			for (size_t i = 0; i < _PrimeSize; i++)
			{
				if (_PrimeList[i]>value)
				{
					return _PrimeList[i];
				}
			}
			return _PrimeList[_PrimeSize - 1];
		}

	};


	void Test()
	{
		HashTable<int, int> ht;
		for (size_t i = 0; i < 100; i++)
		{
			ht.Insert(make_pair(i, i));
		}

		//HashTable<string, string> dict;
		//dict.Insert(make_pair("left", "左边"));

		ht.Remove(1);
		 
		ht.Find(50);
	}
}

 


23、开放寻址哈希法：二次探测与双重哈希解析
life6的博客
07-21 31
本文详细解析了开放寻址哈希法中的两种关键技术：二次探测和双重哈希。文章首先分析了线性探测中存在的主聚类和次聚类问题，并介绍了如何通过二次探测和双重哈希来优化哈希表性能。通过理论分析和 C++ 代码示例，展示了双重哈希在解决聚类问题和提升探测效率方面的优势。同时，文章还探讨了哈希表负载因子的影响、数组扩展策略以及开放寻址方法的效率问题。最后，通过 Workshop 部分提供了相关练习和测验，帮助读者巩固所学内容。
【数据结构】考点十七： 散列表（线性探查算法 + 二次探测法）
最新发布
超越的博客
04-19 2717
散列表（Hash Table），也称为哈希表或字典，是一种使用哈希函数组织数据结构，以便进行快速数据查找的数据结构。哈希表通过计算键（key）的哈希值（hash value），将键映射到哈希表中的一个位置，从而实现数据的快速存取。线性探查算法与二次探测法 是一种解决哈希冲突的方法。
用二次探测再散列法解决冲突建立哈希表并查找
07-21
这是数据结构课程作业，用二次探测再散列法解决冲突建立哈希表并查找 从键盘读入 待查找 的权重数值，以除留余数法为哈希函数，二次探测再散列法解决冲突建立哈希表，基于哈希算法从数组中查找相应的记录，计算相应的查找时间，并在屏幕上输出显示。
哈希表线性探测&二次探测
z517602658的博客
06-09 2760
在代码中实现了哈希表中任意类型都可以存放，即哈希函数要可扩展以及哈希表动态增容的功能。 贴上代码： #include #include using namespace std; template//特化 class _HashFun { public: size_t operator()(K key) { return key; } }; template<>
HashTable哈希表/散列表（线性探测和二次探测）
simplehap的博客
04-24 2万+
HashTable的简单介绍HashTable是根据关键字直接访问在内存存储的数据结构。 HashTable叫哈希表或者散列表。 它通过一个关键值的函数将所需的数据直接映射到表中的位置来访问数据，这个映射函数叫散列函数（哈希函数），存放记录的数组叫散列表（哈希表）。比如： 给定一字符串“abckhdgubhkacdggk”找出第一次只出现一次的字符。
哈希表线性探测再散列（纯数字）
12-22
c代码实现哈希表线性探测再散列。关键字均为纯数字。查找时为单次查找，未加入循环
开放地址法哈希实现——线性探测法
实践求真知
07-29 1199
线性探测法是最简单的开发地址法，线性探测的增量序列为d=1,2...m-1。
开放地址法哈希实现——二次探测法
实践求真知
07-29 1万+
二次探测法是指采用前后跳跃方式探测的方法，发生冲突时，向后1位探测，向前1位探测，向后4位探测，向前4位探测......以跳跃式探测，避免堆积。二次探测的增量序列为d=1，-1,4，-4,9，-9。
基于C语言实现哈希表（线性探测）
L_X_Y_HH的博客
05-28 3406
之前在写过的很多的结构中都实现过搜索功能，但是不论是顺序搜索还是搜索二叉树，由于元素的存储位置和元素各关键码之间没有对应的关系，所以在查找一个元素的时候必须要经过关键码的多次比较。因此搜索的时间复杂度很难能够达到O(1)。但是如果有一种存储结构，通过某种函数使元素的存储位置与他的关键码之间能够建立一一映射的关系，那么就能够直接地查找到需要地元素，时间复杂度就达到了O(1)，那么这种结构就是哈希表。...
133-哈希表-线性探测法代码实现
Edward_LF的博客
05-02 775
1、哈希表-线性探测法理论 线性探测法的理论我们在上一篇博客已经阐述了。 现在我们来看看线性探测法的增删查的代码思想： 1.1、哈希表的增加元素 注意： 往后遍历寻找空闲位置的时候，要注意是环形遍历哦！不然访问数组就越界了。 在添加元素，发生位置被占用，即发生哈希冲突后，在向后遍历寻找空闲位置的时候，我们要知道，这个空闲的位置是有两种情况的： 1、这个位置一直是空的，没放过元素。 2、这个位置是空的，以前放过元素，后来被删除了。 1.2、哈希表的查询操作 当用哈希函数计算得出的下标值是3
哈希表之二次探测法
m0_72542983的博客
02-08 5967
二次探测法
哈希表之线性探测和二次探测
菱形继承
02-29 3539
哈希表又称散列表。 哈希表存储的基本思想是：以数据表中的每个记录的关键字 k为自变量，通过一种函数H(k)计算出函数值。把这个值解释为一块连续存储空间（即数组空间）的单元地址（即下标），将该记录存储到这个单元中。在此称该函数H为哈函数或散列函数。按这种方法建立的表称为哈希表或散列表。 处理冲突的方法： 开放寻址法：Hi=(H(key) + di) MOD m, i=1,2,…, k(k&lt...
哈希表（散列表）二次探测
weixin_34128411的博客
06-10 426
#pragmaonce #include<iostream> #include<string> usingnamespacestd; enumState { EMPTY, DELETE, EXIST, }; template<classK,classV> structHashTableNode { K_key; V_va...
构造哈希表之二次探测法
热门推荐
dream
06-08 7万+
HashTable-散列表/哈希表 是根据关键字（key）而直接访问在内存存储位置的数据结构。 它通过一个关键值的函数将所需的数据映射到表中的位置来访问数据，这个映射函数叫做散列（哈希）函数，存放记录的数组叫做散列表。 构造哈希表的几种方法 1.直接定址法（取关键字的某个线性函数为哈希地址） 2.除留余数法（取关键值被某个不大于散列表长m的数p除后的所得的余数为散列地址） 3.
哈希冲突的处理【闭散列方法-线性探测和二次探测】
weixin_33806509的博客
05-07 981
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数Hash(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希...
二次探测法
小小程序员
05-04 3万+
设哈希表长为11，哈希函数为Hash (key)=key%11。存在关键码{43,7,29,22,16,92,44,8,19}，采用二次探测法处理冲突，建立的hash表为（ ） 二次探测法：采用开放定址法处理冲突中的二次探测再散列（也即是题目中的二元探测法）,则哈希函数变为Hash(key） = (Hash(key) + d) % 11，其中d = 1^2, -1^2, 2^2, -2^2...
散列表(线性探测法&二次探测法)
weixin_37231962的博客
04-04 3133
线性探测法 将关键字序列（7、8、30、11、18、9、14）散列存储到散列表中 （7） Key 7 8 30 11 18 9 14 H(Key) 0 3 6 5 5 5 6 冲突处理：(位置被占有继续往下找) 地址 0 1 2 3 4 5 6 7 8 9 关键字 7 14 8 11 30 18 9 线性探测法 f(key) = (f(key)+di) MOD m (di=1,2,3,…,m-1) 二次探测法 f(key) = (f(key)+di
构造哈希表以及二次探测法
Stu_zkl的博客
09-16 1万+
构造哈希表（散列表）以及二次探测法 今天做笔试题时，遇到一道构造哈希表的题，hash函数是 k%11 ，然后一个数组记不清了，然后就是问二次探测法进行，问下面那个是正确，懵逼啊，没做过，不知道，乱选直接下一题，于是有这个博客，赶紧学习一波。 网上查询了一下。 构造哈希表的几种方法 常用方法是直接定址法和除留余数法 直接定址法（取关键字的某个线性函数为哈希地址） 类似于这样的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值