【数据结构】—— 哈希表之闭散列解决哈希冲突

最新推荐文章于 2024-08-27 11:09:59 发布

CXYhh121

最新推荐文章于 2024-08-27 11:09:59 发布

阅读量1.2k

点赞数 1

分类专栏： C++学习数据结构学习代码文章标签：哈希概念哈希函数哈希冲突闭散列解决哈希冲突

本文链接：https://blog.csdn.net/chenxiyuehh/article/details/90043229

版权

C++学习同时被 2 个专栏收录

39 篇文章 5 订阅

订阅专栏

数据结构学习代码

22 篇文章 1 订阅

订阅专栏

一、底层结构

unordered_set/map介绍
https://blog.csdn.net/chenxiyuehh/article/details/89737056
unordered_set/map应用
https://blog.csdn.net/chenxiyuehh/article/details/89964419

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

二、哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( $log_2 N$ )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

举个栗子理解一下
LeetCode387题字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:

s = “leetcode”
返回 0.
s = “loveleetcode”,
返回 2.

直接定制法

我们可以看到我们在解决该问题的时候是开辟了一个大小为26的数组(只出现小写字符),然后将出现的字符映射到数组对应的位置，并在对应位置进行计数，这就是哈希的思想，但是这种思想只适用与已知序列较小并且是连续的情况。

三、哈希冲突

3.1 概念

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

3.2 栗子

我们来看一个栗子理解一下什么是哈希冲突：
例如：我们有数据集合{1，7，6，4，5，9，16 , 10 , 19 , 21}
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

四、哈希函数

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

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有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)作为哈希地址平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法
数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

哈希冲突解决之闭散列

闭散列

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

线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

举个栗子
哈希冲突的解决

线性探测实现

存储元素定义

定义一个哈希表中存储的元素类型，我这里定义为HashNode,存储的是键值对pair<K,V>,考虑到哈希表的删除问题，直接将元素删除会影响哈希地址相同的另一个元素的查找，因此需要存储哈希表中存储元素的状态。

// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State
{
	EMPTY,
	DELETE,
	EXIST
};//

template<class K,class V>
struct HashNode
{
	pair<K, V> _kv;
	State _state;//元素状态
};

插入元素

通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

	bool Insert(const pair<K, V>& kv)
	{
		size_t index = kv.first % _table.size();
		while (_table[index]._state == EXIST)
		{
			if (_table[index]._kv.first == kv.first)
			{
				return true;
			}

			//线性探测解决哈希冲突问题
			++index;
			if (index == _table.size())
				index = 0;
		}
		//若是该位置没值，直接插入
		_table[index]._kv = kv;
		_table[index]._state = EXIST;
		_size++;

		return true;
	}

删除元素

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素6，如果直接删除掉，16查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

	bool Erase(const K& key)
	{
		HashNode* node = Find(ket);
		if (node != nullptr)
		{
			node->_state = DELETE;
			--_size;
			return true;
		}
		else
		{
			return false;
		}
	}

查找元素

思想很简单，通过哈希函数找到该元素的对应位置，由于有冲突问题，该位置不一定是要查找的元素，因此我们需要像插入一个元素一样，顺序往后查找这个元素，若是遇到哈希表中状态为EMPTY时停止查找，找到返回该元素的地址，无法返回下标，因为哈希表是私有成员，在类外无法进行访问，返回下标无意义。

	HashNode* Find(const K& key)
	{
		size_t index = key%_table.size();
		while (_table[index]._state != EMPTY)
		{
			if (_table[index]._kv.first == key && _table[index] == EXIST)
			{
				return &_table[index];
			}

			++index;
			if (index == _table.size())
				index = 0;
		}
		return nullptr;
	}

哈希表的增容

这里解释一下一个概念：负载因子load factor = 哈希表的大小 / 有效元素的个数，负载因子越小，出现哈希冲突的概率越低，哈希表的效率越高，但是浪费的空间越多
这里我把负载因子控制在0.7，当负载因子大于0.7时开始增容，思路是开辟一个新的哈希表，遍历旧表重新计算元素在新表中的位置，计算好了之后，交换两个表
这里使用了一个很巧妙的方法，交换两个表之后，旧表更新为newht，得到了新的空间和对应元素的位置，而我们创建的临时对象newht为本函数中的局部对象，出了该函数了作用域之后会自动调用析构函数释放旧表资源，就不需要我们手动释放原来旧表的资源了。

	void CheckCapacity()
	{
		//load factor 等于0.7开始增容，负载因子越小效率越高，空间浪费越多
		if (_tabele.size() == 0 || (_size * 10) / _table.size() == 7)
		{//增容
			size_t newcapacity = _table.size() == 0 ? 10 : _table.size() * 2;
			HashTable<K, V> _newht(newcapacity);
			//旧表的数据重新计算在新表中的位置
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i]._state == EXIST)
					_newht.Insert(_table[i]._kv);
			}
			//交换之后，旧表更新为newht，newht为本函数中的局部对象，
			//出了该函数了作用域之后会自动调用析构函数释放旧表资源
			_table.swap(_newht._table);	
		}
	}

线性探测完整代码

#pragma once
#include <iostream>
#include <vector>
using namespace std;

enum State
{
	EMPTY,
	DELETE,
	EXIST
};

template<class K,class V>
struct HashNode
{
	pair<K, V> _kv;
	State _state;
};


template<class K, class V>
class HashTable
{
	typedef HashNode<K, V> HashNode;
public:
	HashTable(size_t N = 10)
	{
		_table.resize(N);
		for (size_t i = 0; i < _table.size(); ++i)
		{
			_table[i]._state = EMPTY;
		}
		_size = 0;
	}

	void CheckCapacity()
	{
		//load factor 等于0.7开始增容，负载因子越小效率越高，空间浪费越多
		if (_tabele.size() == 0 || (_size * 10) / _table.size() == 7)
		{//增容
			size_t newcapacity = _table.size() == 0 ? 10 : _table.size() * 2;
			HashTable<K, V> _newht(newcapacity);
			//旧表的数据重新计算在新表中的位置
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i]._state == EXIST)
					_newht.Insert(_table[i]._kv);
			}
			//交换之后，旧表更新为newht，newht为本函数中的局部对象，
			//出了该函数了作用域之后会自动调用析构函数释放旧表资源
			_table.swap(_newht._table);	
		}
	}

	bool Insert(const pair<K, V>& kv)
	{
		size_t index = kv.first % _table.size();
		while (_table[index]._state == EXIST)
		{
			if (_table[index]._kv.first == kv.first)
			{
				return true;
			}

			//线性探测解决哈希冲突问题
			++index;
			if (index == _table.size())
				index = 0;
		}

		//若是该位置没值，直接插入
		_table[index]._kv = kv;
		_table[index]._state = EXIST;
		_size++;

		return true;
	}

	HashNode* Find(const K& key)
	{
		size_t index = key%_table.size();
		while (_table[index]._state != EMPTY)
		{
			if (_table[index]._kv.first == key && _table[index] == EXIST)
			{
				return &_table[index];
			}

			++index;
			if (index == _table.size())
				index = 0;
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		HashNode* node = Find(ket);
		if (node != nullptr)
		{
			node->_state = DELETE;
			--_size;
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	//HashNode* _table;
	//size_t _size;//有效数据个数
	//size_t _capacity;//哈希表的空间大小

	vector<HashNode> _table;
	size_t _size;//哈希表中有效数据的个数
};

void TestHashTable()
{
	HashTable<int, int> ht;
	int a[] = { 3, 2, 5, 1 };
	for (auto& e : a)
	{
		ht.Insert(make_pair(e, e));
	}
}

二次探测

线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： $H_i$ = ( $H_0$ + $i^2$ )% m, 或者： $H_i$ = ( $H_0$ - $i^2$ )% m。其中：i = 1,2,3…， $H_0$ 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。对于2.1中如果要插入44，产生冲突，使用解决后的情况为：
二次探测
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。