探索数据结构：哈希表的分析与实现

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 哈希的引入

1.1. 哈希的概念

无论是在顺序结构还是在树形结构中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度一般为 $O (N)$ ，而平衡树中查找的时间复杂度为树的高度 $O (l o g N)$ 。为了进一步提高查找效率，就有人提出了哈希的概念。

哈希简单来说就是通过构造一种存储结构，该结构能够通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时就能通过该函数很快找到该元素。该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(散列表)。

1.2. 构建哈希表

一般我们利用数组来构建哈希表，建立数组下标与数据元素之间的映射关系，那么在查找时就可以通过数组下标以 $O (1)$ 的时间复杂度找到该元素。简单来说可以分为以下两个步骤：

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

例如：

我们将集合{1,3,5,6}中所有元素插入一个哈希表中，哈希函数设置为：hash(key)=key%capacity，其中capacity为存储元素底层空间的总大小，这里假设为8。

2. 哈希冲突

2.1. 哈希冲突的概念

哈希冲突，也称为散列冲突，是指在使用哈希函数进行数据存储或检索时，不同的输入数据经过哈希函数计算后得到了相同的哈希值。

比如我们继续以上面的例子为例，插入一个元素9会发生什么呢？

2.2. 哈希函数的设计

哈希冲突发生的一个重要的一个原因就是：哈希函数设计不合理。我们在设计哈希函数时应遵循以下规则：

哈希函数的定义域必须包括需要存储的全部关键码，且如果散列表允许有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)作为哈希地址。
适用场景：不知道关键字的分布，而位数又不是很大的情况。

四、折叠法

步骤：将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
适用场景：事先不需要知道关键字的分布，适合关键字位数比较多的情况。

五、随机数法

公式：Hash(key) = random(key)，其中random为随机数函数。
适用场景：通常应用于关键字长度不等时采用此法。

六、数学分析法

方法：设有n个d位数，每一位可能有r种不同的符号，选择其中各种符号分布均匀的若干位作为散列地址。例如存储某家公司员工登记表，用手机号作为关键字，可选择后面的四位作为散列地址，若还容易出现冲突，可对抽取出来的数字进行反转、右环位移、左环位移、前两数与后两数叠加等方法。
适用场景：数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

3. 哈希冲突的解决

虽然哈希函数设计的越精确，发生哈希冲突的可能性就越低，但都无法彻底避免哈希冲突。所以为了解决这个问题，提出了两种方法：闭散列与开散列。

3.1. 闭散列

闭散列，也称为开放定址法，是一种解决哈希冲突的方法。在这种方法中，当发生哈希冲突时，通过在哈希表中寻找另一个空闲位置来存储冲突的数据。

具体思路为当使用哈希函数计算出一个关键字的哈希地址后，如果该地址已经被占用（发生了哈希冲突），则按照一定的探测方法在哈希表中寻找下一个空闲位置来存储该关键字。这个过程一直持续到找到一个空闲位置或者遍历完整个哈希表。

其中探测方法主要有以下两种：

线性探测

从发生冲突的位置开始，依次向后查找下一个空闲位置。即如果哈希地址为i的位置被占用，那么依次检查i+1、i+2、i+3等位置，直到找到一个空闲位置，如果超出范围则进行取模。
优点是实现简单。缺点是容易产生聚集问题，即连续的位置被占用后，后续的插入操作会越来越困难，导致查找时间增加。

二次探测

按照一定的步长进行查找，避免了线性探测中可能出现的聚集问题。具体来说，如果哈希地址为i发生冲突，第一次探测的位置是i + 1²，第二次探测的位置是i + 2²，第三次探测的位置是i + 3²，第四次探测的位置是i + 4²，以此类推，如果超出范围则进行取模。
相比线性探测，减少了聚集现象，但仍然可能存在一定程度的聚集。

继续借用上面的例子，我们插入元素9会发生哈希冲突，这时我们采用线性探测该元素会插入到2号位置。

如果我们继续插入元素11，采用二次探测的方式，该元素就会插入到4号位置。

通过上面观察我们知道当我们插入元素越多发生哈希冲突的可能性就越大，为了避免这种情况这时我们就需要扩容，而扩容需要我们设置一个参照条件判断当前是否需要扩容，这个条件在哈希表中被称为负载因子。

负载因子 = 表中有效数据个数 / 空间的大小

其中负载因子越大，产出冲突的概率越高，增删查改的效率越低。负载因子越小，产出冲突的概率越低，增删查改的效率越高。一般负载因子超过0.7就需要进行扩容。

3.2. 开散列

开散列又叫链地址法(开链法)，也是一种解决哈希表的方法。具体来说就是对关键码集合用哈希函数计算哈希地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中，所以也叫哈希桶。

比如我们将集合{1,3,5,6,9,11,17}中所有元素插入一个哈希表中，哈希函数设置为：hash(key)=key%capacity，其中capacity为假设为8。

当然开散列也需要设置负载因子，而且开散列的负载因子可以大于1，但是我们一般建议设置在0~1之间。并且开散列还存在一种极端情况那就是所有元素都冲突，被放在一个桶里。此时增删查改的效率就会劣化为 $O (N)$

为了解决这个情况，当每个桶中的元素超过一定长度之后，将单链表结构改为红黑树结构，将红黑树的根节点存放在哈希表中。这样保证即使是极端情况，查找效率也可以保持 $O (l o g N)$ 。

但是有些实现就没有这样的方式，因为随着数据的增多，负载因子就会增大最终就会导致扩容，一旦扩容哈希冲突的个数就会减少，所以不做任何处理也是可行的。

4. 哈希表的功能

哈希表的功能主要有以下三个：

哈希表的插入。
哈希表的查找。
哈希表的删除。

5. 哈希表的结构

5.1. 闭散列的结构

在使用闭散列的哈希中，如果要删除某个数据我们为了保持原有的结构不可能采用的覆盖的形式，所以我只好采用一种伪删除的方式，即对删除节点进行标记。而标记State的方式有三种：EMPTY(无数据)，EXIST(存在数据)，DELETE(删除)，所以说每个哈希节点的结构如下：

enum State
{
	EMPTY,//不存在数据
	EXIST,//存在数据
	DELETE//已删除
};
template<class K,class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};

而在哈希表中，我们以数组的方式存放数据，并且为了方便计算负载因子，需要增加一个记录有效元素个数的变量_n。其中为了方便描述我们可以使用typedef简化。

template<class K,class V>
class HashTable
{
	typedef HashData<K, V> Node;
public:
	//具体实现
private:
	vector<Node> _table;//哈希表
	size_t _n = 0;//有效数据个数
};

5.2. 开散列的结构

在开散列中每一个的元素存放的都是一个链表，所以节点结构参照链表实现即可。

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)
    {}
};

哈希表的结构就与闭散列的类似，都存在表示一个变量_n表示有效元素的个数。并且数组元素存放的是一个地址。

template<class K,class V>
class HashTable
{
	typedef HashData<K, V> Node;
public:
	//具体实现
private:
	vector<Node*> _table;//哈希表
	size_t _n = 0;//有效数据个数
};

6. 哈希表的功能

6.1. 哈希表的插入

6.1.1. 闭散列

闭散列的插入首先得考虑扩容的情况，一般而言当负载因子大于0.7就需要扩容，而扩容就会影响原来哈希表的映射关系，所以这时就需要将原哈希表的元素重新通过哈希函数映射到新的哈希表中，这里我们可以采用类似递归的方式插入简化过程。最后通过交换使原哈希表出了作用域之后销毁。

最后插入过程只需要通过哈希函数找到对应的位置，如果发生哈希冲突则进行线性探测或者二次探测，最后再增加有效元素个数。

其中这里注意：因为闭散列的负载因子是控制以0.7以内的，所以一定能找到插入位置。

bool Insert(const pair<K, V>& kv)
{
	// 查找是否已存在相同键的节点
	Node* ret = Find(kv.first);
	if (ret)
	{
		return false;
	}
	// 如果哈希表为空，则初始化大小为 10
	if (_table.size() == 0)
	{
		_table.resize(10);
	}
	// 负载因子大于 0.7 则扩容
	else if ((double)_n / _table.size() > 0.7)
	{
		HashTable<K, V> newHT;
		// 新哈希表大小为原哈希表的两倍
		newHT._table.resize(2 * _table.size());
		for (auto& e : _table)
		{
			// 如果当前位置的状态为已存在，则将其插入新哈希表
			if (e._state == EXIST)
			{
				// 用类似递归的方式复用插入操作
				newHT.Insert(e._kv);
			}
		}
		// 通过交换让原本哈希表自动回收，同时新哈希表成为当前使用的哈希表
		_table.swap(newHT._table);
	}
	// 计算起始位置，capacity 中有些空间还未初始化，所以只能模 size
	size_t start = kv.first % _table.size();
	size_t index = start;
	size_t hashi = 1;
	// 找到空位置用于插入新节点
	while (_table[index]._state == EXIST)
	{
        //线性探测
        hashi++;
        //二次探测
        //index = start + hashi*hashi
	}
	// 将新的键值对插入到找到的空位置
	_table[index]._kv = kv;
	_table[index]._state = EXIST;
	// 有效数据数量加一
	_n++;
	return true;
}

6.1.2. 开散列

开散列的插入也需要考虑扩容，但是开散列因为存放的是一个链表，所以空间利用率就比较高，这时我们的负载因子可以设为1。而同样我们也需要将原数据映射到新的哈希表中，这里我们可以通过遍历原哈希表对新的哈希表进行头插的形式，最后通过交换使原哈希表出了作用域之后销毁。

插入过程也十分简单，因为是开散列所以直接通过哈希函数映射到相应位置，然后进行头插，然后增加有效元素个数即可。

bool Insert(const pair<K, V>& kv)
{
	// 查找是否已存在相同键的节点
	Node* ret = Find(kv.first);
	if (ret)
	{
		return false;
	}
	// 如果负载因子等于 1 进行扩容
	if (_n == _table.size())
	{
		vector<Node*> newHT;
		// 如果原哈希表大小为 0，则新哈希表大小为 10，否则为原大小的两倍
		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		newHT.resize(newSize);
		for (int i = 0; i < _table.size(); i++)
		{
			if (_table[i])
			{
				Node* cur = _table[i];
				// 遍历链表进行头插更新节点进新的哈希表
				while (cur)
				{
					// 记录下一个节点
					Node* next = cur->_next;
					size_t index = cur->_kv.first % newHT.size();
					// 进行头插
					cur->_next = newHT[index];
					newHT[index] = cur;
					cur = next;
				}
				// 将原哈希桶置空
				_table[i] = nullptr;
			}
		}
		// 通过交换让原本哈希表自动回收，同时新哈希表成为当前使用的哈希表
		_table.swap(newHT);
	}
	// 计算插入位置
	size_t index = kv.first % _table.size();
	Node* newnode = new Node(kv);
	// 进行头插
	newnode->_next = _table[index];
	_table[index] = newnode;
	_n++;
	return true;
}

6.2. 哈希表的查找

6.2.1. 闭散列

查找逻辑就比较简单了，直接通过哈希函数计算相应的位置，然后通过线性探测与二次探测一一比较，如果比对成功且该元素存在那么查找成功，如果查找到空节点那么查找失败。

Node* Find(const K& key)
{
    if (_table.size() == 0)
    {
        return nullptr;
    }
    //capacity中有些空间还未初始化，所以只能模size
    size_t start = key % _table.size();
    size_t index = start;
    size_t hashi = 1;
    //闭散列中哈希表中一定有空位置，如果是EMPTY则未找到
    while (_table[index]._state != EMPTY)
    {
        if (_table[index]._state == EXIST && _table[index]._kv.first == key)
        {
            return &_table[index];
        }
        //线性探测
        index = start + hashi;
        //二次探测
        //index = start + i*i
        index %= _table.size();
        hashi++;
    }
    return nullptr;
}

6.2.2. 开散列

开散列的查找就更简单了，只需通过对应的哈希函数找到插入位置遍历链表查找即可。

Node* Find(const K& key)
{
    if (_table.size() == 0)
    {
        return nullptr;
    }
    size_t index = key % _table.size();
    Node* cur = _table[index];
    while (cur)
    {
        if (cur->_kv.first == key)
        {
            return cur;
        }
        cur = cur->_next;
    }
    return nullptr;
}

6.3. 哈希表的删除

6.3.1. 闭散列

闭散列可以通过服用查找函数，如果找到了则将对应元素改为删除状态减少有效元素个数，否则返回nullptr。

bool Erase(const K& key)
{
    //找到删除目标
    Node* ret = Find(key);
    if (!ret)
    {
        return false;
    }
    //找到了进行伪删除
    ret->_state = DELETE;
    _n--;
    return true;
}

6.3.2. 开散列

开散列就不能服用插入函数了，因为我们删除节点需要先找到该节点的前一个节点.，所以只能通过重新遍历查找，最后链接前后节点再使有效元素个数减少即可。

bool Erase(const K& key)
{
	size_t index = key % _table.size();
	//记录前一个节点方便链接
	Node* prev = nullptr;
	Node* cur = _table[index];
	while (cur)
	{
		//找到
		if (cur->_kv.first == key)
		{
			//如果为头节点
			if (prev == nullptr)
			{
				_table[index] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			delete cur;
			--_n;
			return true;
		}
		//没找到的话就遍历下一个
		prev = cur;
		cur = cur->_next;
	}
	return false;
}

思考题：为什么除留余数法这种方法的模数建议为素数，并且又该如何实现呢？

因为当我们使用素数作为模数时，可以最大程度保证哈希值的均匀分布·。因为素数不会与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。比如，假设我们选择合数 9 作为模数，它可以被 3 整除。那么所有可以被 3 整除的 key 都会被映射到 0、3、 6 这三个哈希值。一旦数据中存在大量3的倍数，哈希冲突就会加剧。而我们选择任意一个素数17，就不会存在这种情况，哈希值也会分布均匀。当然如果能保证数据的随机性，那么无论选择合数还是素数都是可以的。所以综上，一般选用素数作为模数会更好。

实现方法如下：

//直接定一个倍数接近2的素数数组
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 GetNextPrime(size_t prime)
{
	const int PRIMECOUNT = 28;
	size_t i = 0;
	for (i = 0; i < PRIMECOUNT; i++)
	{
		if (primeList[i] > prime)
			return primeList[i];
	}
	return primeList[i];
}

思考题：为什么闭散列中的状态要由DELETE，删除之后设为EMPTY不也可以吗？

因为一旦将删除元素的状态设置为EMPTY，在查找时根本分不清该空节点是否应该结束。

7. 源码

7.1. 闭散列

namespace open_address
{
	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
	{
		typedef HashData<K, V> Node;
	public:
		//具体实现
		bool Insert(const pair<K, V>& kv)
		{
			// 查找是否已存在相同键的节点
			Node* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			// 如果哈希表为空，则初始化大小为 10
			if (_table.size() == 0)
			{
				_table.resize(10);
			}
			// 负载因子大于 0.7 则扩容
			else if ((double)_n / _table.size() > 0.7)
			{
				HashTable<K, V> newHT;
				// 新哈希表大小为原哈希表的两倍
				newHT._table.resize(2 * _table.size());
				for (auto& e : _table)
				{
					// 如果当前位置的状态为已存在，则将其插入新哈希表
					if (e._state == EXIST)
					{
						// 用类似递归的方式复用插入操作
						newHT.Insert(e._kv);
					}
				}
				// 通过交换让原本哈希表自动回收，同时新哈希表成为当前使用的哈希表
				_table.swap(newHT._table);
			}
			// 计算起始位置，capacity 中有些空间还未初始化，所以只能模 size
			size_t start = kv.first % _table.size();
			size_t index = start;
			size_t hashi = 1;
			// 找到空位置用于插入新节点
			while (_table[index]._state == EXIST)
			{
				index = start + hashi;
				index %= _table.size();
				//线性探测
				hashi++;
				//二次探测
                //index = start + hashi*hashi
			}
			// 将新的键值对插入到找到的空位置
			_table[index]._kv = kv;
			_table[index]._state = EXIST;
			// 有效数据数量加一
			_n++;
			return true;
		}

		Node* Find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}
			//capacity中有些空间还未初始化，所以只能模size
			size_t start = key % _table.size();
			size_t index = start;
			size_t hashi = 1;
			//闭散列中哈希表中一定有空位置，如果是EMPTY则未找到
			while (_table[index]._state != EMPTY)
			{
				if (_table[index]._state == EXIST && _table[index]._kv.first == key)
				{
					return &_table[index];
				}
				//线性探测
				index = start + hashi;
				//二次探测
				//index = start + i*i
				index %= _table.size();
				hashi++;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			//找到删除目标
			Node* ret = Find(key);
			if (!ret)
			{
				return false;
			}
			//找到了进行伪删除
			ret->_state = DELETE;
			_n--;
			return true;
		}
	private:
		vector<Node> _table;//哈希表
		size_t _n = 0;//有效数据个数
	};
}

7.2. 开散列

namespace hash_bucket
{
	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 HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		
		bool Insert(const pair<K, V>& kv)
		{
			// 查找是否已存在相同键的节点
			Node* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			// 如果负载因子等于 1 进行扩容
			if (_n == _table.size())
			{
				vector<Node*> newHT;
				// 如果原哈希表大小为 0，则新哈希表大小为 10，否则为原大小的两倍
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				newHT.resize(newSize);
				for (int i = 0; i < _table.size(); i++)
				{
					if (_table[i])
					{
						Node* cur = _table[i];
						// 遍历链表进行头插更新节点进新的哈希表
						while (cur)
						{
							// 记录下一个节点
							Node* next = cur->_next;
							size_t index = cur->_kv.first % newHT.size();
							// 进行头插
							cur->_next = newHT[index];
							newHT[index] = cur;
							cur = next;
						}
						// 将原哈希桶置空
						_table[i] = nullptr;
					}
				}
				// 通过交换让原本哈希表自动回收，同时新哈希表成为当前使用的哈希表
				_table.swap(newHT);
			}
			// 计算插入位置
			size_t index = kv.first % _table.size();
			Node* newnode = new Node(kv);
			// 进行头插
			newnode->_next = _table[index];
			_table[index] = newnode;
			_n++;
			return true;
		}
		
		Node* Find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}
			size_t index = key % _table.size();
			Node* cur = _table[index];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			size_t index = key % _table.size();
			//记录前一个节点方便链接
			Node* prev = nullptr;
			Node* cur = _table[index];
			while (cur)
			{
				//找到
				if (cur->_kv.first == key)
				{
					//如果为头节点
					if (prev == nullptr)
					{
						_table[index] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				//没找到的话就遍历下一个
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _table;//哈希表
		size_t _n = 0 ;//有效数据个数
	};
}
ile (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			size_t index = key % _table.size();
			//记录前一个节点方便链接
			Node* prev = nullptr;
			Node* cur = _table[index];
			while (cur)
			{
				//找到
				if (cur->_kv.first == key)
				{
					//如果为头节点
					if (prev == nullptr)
					{
						_table[index] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				//没找到的话就遍历下一个
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _table;//哈希表
		size_t _n = 0 ;//有效数据个数
	};
}