数据结构篇【4】——哈希（散列）线性探测实现

JayceSun449

已于 2022-06-27 16:04:45 修改

阅读量1.4k

点赞数 2

分类专栏：数据结构/算法文章标签：哈希算法数据结构散列表

于 2022-06-27 14:08:52 首次发布

本文链接：https://blog.csdn.net/jaycesun/article/details/125434261

版权

数据结构/算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

哈希

构造一种存储结构，通过某种函数（hashFunc）使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。最理想的情况是可以不经过任何比较，一次直接从表中得到要搜索的元素。

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

哈希冲突

对于两个数据元素的关键字k_i和k_j(i != j),有k_i != k_j,但有Hash(k_i) == Hash(k_j)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

哈希函数

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

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

常见的哈希函数

直接定制法
取关键字的某个线性函数为散列地址：Hash(Key) = A*Key + B优点：简单、均匀缺点：需要提前知道关键字的分布情况使用场景：适合比较小且连续的情况
除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key%p(p<=m)，将关键码转换成哈希地址
平方取中法
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址，再比如关键字为4321，对它平方就是18671041，抽取中间的3位671（或710）作为哈希地址，平方取中法比较适合不知道关键字的分布，而位数又不是很大的情况

哈希冲突的解决方法

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

闭散列

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

线性探测

如上图所示，现在我们想在哈希表中插入44，那么通过求余数我们发现44应该在下标为4的位置上，但这个位置已经被4占据，因此44应该不断向后查找一个空余的位置，在这里一直到8号下标才找到空余位置
二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：H_i = (H₀ + i²) % m，计算得到的位置，m是表的大小。照这样的思路，上面的例子中要插入的44的位置就应该这样去找，先找下标为(4 + 1²) % 10的位置，此位置被占，继续找4后第(4 + 2²) % 10个位置，此位置没被占，下标为8。
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不用考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
接下来我们先用代码来实现一个线性探测的哈希，首先我们来创建哈希表中存储元素的类,

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

哈希表中存储的元素包含两部分，分别是KeyValue对和该位置此时的状态，首先将_status赋默认值EMPTY，这样可以在HashTable在建立时自动初始化。
下一步我们要考虑如何把key值转化为可以取模的整型，key值可以有多种类型，比如int，string等，当我们得到的数据是int时可以直接进行取模，但是如果传入的key值是string类型，那么我们就需要对这些类型进行特殊的转换，因此我们还需要设计对应的哈希函数来处理这些key值

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 *= 31; // 这样的计算可以减少冲突
			value += ch;
		}
		return value;
	}
};

这段代码中我们给传入的key值创建的默认哈希函数是直接返回key值，对应于整形，而对于string类型我们进行了特化处理，将它也转化为一个整型。
接着我们来看看HashTable的基本框架，

template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0;
	};

我们不需要给HashTable类设计构造函数，因为我们在创建成员变量_n时已经给它赋初始值0，因此在初始化列表会自动给他初始化，而对于_tables，他会自动调用HashData的构造函数，而和_n相同的的原理，_status也会在初始化列表中被自动赋初值。
接下来就要开始实现接口了，首先我们来看看Find如何实现，

		HashData<K, V>* Find(const K& key)
		{
			// 必须检查表的大小是否为0，否则在
			// 之后的代码会出现除数为0的错误
			if (_tables.size() == 0)
			{
				return nullptr;
			}

			HashFunc hf;
			size_t start = hf(key) % _tables.size();
			size_t i = 0;
			size_t index = start;
			// 当元素为空时还未找到目标值就说明表中无目标值
			// 若元素的状态为DELETE时应该继续向后查找
			while (_tables[index]._status != EMPTY)
			{
				if (_tables[index]._kv.first == key && _tables[index]._status == EXIST)
				{
					return &_tables[index];
				}
				++i;
				index = start + i;
				index %= _tables.size();
			}
			return nullptr;
		}

接下来我们先实现Erase接口，

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

当我们删除元素时不应该直接将元素删除，而是用一个特殊标记(DELETE)来表明该元素已被删除，因为我们查找元素失败的判断标志就是是否碰到空位置，因此直接删除元素会导致在之后查找元素时碰到问题。
最后我们来看看如何实现Insert接口，

		bool Insert(const pair<K, V>& kv)
		{
			// 如果已有该元素则插入失败
			HashData<K, V>* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			// 负载因子到0.7，就扩容
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				// 扩容
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V, HashFunc> newHT;
				newHT._tables.resize(newSize);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._status == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			HashFunc hf;
			size_t start = hf(kv.first) % _tables.size();
			size_t i = 0;
			size_t index = start;
			while (_tables[index]._status == EXIST)
			{
				++i;
				index = start + i;
				index %= _tables.size();
			}
			_tables[index]._kv = kv;
			_tables[index]._status = EXIST;
			++_n;
			return true;
		}

这样我们就完成了线性探测的哈希表，下面是完整的代码

HashTable

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 *= 31; // 这样的计算可以减少冲突
			value += ch;
		}
		return value;
	}
};

namespace ssj
{
	enum Status
	{
		EXIST,
		EMPTY,
		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:
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
			{
				return false;
			}
			else
			{
				--_n;
				ret->_status = DELETE;
				return true;
			}
		}

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

			HashFunc hf;
			size_t start = hf(key) % _tables.size();
			size_t i = 0;
			size_t index = start;
			while (_tables[index]._status != EMPTY)
			{
				if (_tables[index]._kv.first == key && _tables[index]._status == EXIST)
				{
					return &_tables[index];
				}
				++i;
				index = start + i;
				index %= _tables.size();
			}
			return nullptr;
		}

		bool Insert(const pair<K, V>& kv)
		{
			HashData<K, V>* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			// 负载因子到0.7，就扩容
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				// 扩容
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V, HashFunc> newHT;
				newHT._tables.resize(newSize);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._status == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			HashFunc hf;
			size_t start = hf(kv.first) % _tables.size();
			size_t i = 0;
			size_t index = start;
			while (_tables[index]._status == EXIST)
			{
				++i;
				index = start + i;
				index %= _tables.size();
			}
			_tables[index]._kv = kv;
			_tables[index]._status = EXIST;
			++_n;
			return true;
		}

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

JayceSun449

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构篇【4】——哈希（散列）线性探测实现

构造一种存储结构，通过某种函数（hashFunc）使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。最理想的情况是可以不经过任何比较，一次直接从表中得到要搜索的元素。对于两个数据元素的关键字ki和kj(i != j),有ki != kj,但有Hash(ki) == Hash(kj)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。引起哈希冲突的一个原因可能是：哈希
复制链接

扫一扫