【C++】 哈希

已于 2023-07-31 19:11:37 修改
阅读量721 收藏 26
点赞数 28
分类专栏： C++ 文章标签： 哈希算法 c++ 算法 visual studio 散列表
于 2023-07-31 19:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67582098/article/details/132028568
版权

一、哈希的概念及其性质

1.哈希概念

在顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。比如顺序表需要从第一个元素依次向后进行查找，顺序查找时间复杂度为O(N)，平衡树中需要从第一层开始逐层往下进行比较，查找的次数为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数

尽管红黑树或者AVL树的查找效率已经很高了，但是还是不够极致，理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素，当向该结构中：

插入元素时 : 根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

搜索元素时 : 对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

我们需要注意的是，不管是顺序查找，平衡树查找还是哈希查找，其key值都是唯一的，也就是说，搜索树和哈希表中都不允许出现相同的key 值

2.哈希函数

哈希函数设计原则：

1.哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间

2.哈希函数计算出来的地址能均匀分布在整个空间中

3.哈希函数应该比较简单

常见哈希函数

1.直接定址法–(常用)

直接定址法取关键字的某个线性函数为散列地址：Hash（Ke）= A*Key + B

它的优点是简单，且不会引起哈希冲突–哈希冲突是指多个不同的key值映射到同一个存储位置，由于直接定址法的key值经过哈希函数转换后得到的值一定是唯一的，所以不存在哈希冲突

直接定址法适用于数据范围比较集中的情况，这样key值映射到哈希表之后，哈希表的空间利用率高，浪费非空间较少，不适用与数据分散的情况，因为这样会导致空间的利用率很低，从而造成空间浪费

下面是一道哈希定址法的典型例子：

387.字符串中第一个唯一字符[LeetCode]

class Solution {
public:
    int firstUniqChar(string s) {
        int arr[26]={0};
        for(size_t i=0;i<s.size();++i)
        {
            // 题目中说明只有小写字母，我们减去字符得到的数作为下标
            arr[s[i]-'a']++;
        }
        // 遍历查找第一个为1的下标
        for(size_t i=0;i<s.size();++i)
        {
            if(arr[s[i]-'a']==1)
            {
                return i;
            }
        }

        return -1;
    }
};

2.除留余数法–(常用)

除留余数法思想 : 设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

我们使用key值对哈希表的大小进行取模得到的树作为哈希映射的地址，将key保存到该地址中，除留余数法的优点是可以处理数据范围分散的数据，缺点是会引发哈希冲突，比如对于数据集合：

数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

在这里插入图片描述

此时，如果我们继续插入数据11，那么通过哈希函数计算出应该存储在下标为1的位置，但是下标为 1的位置引进存放了数据1，此时就会发生哈希冲突

3.平方取中法–(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4.折叠法–(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5.随机数法–(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。

通常应用于关键字长度不等时采用此法

6.数学分析法–(了解)

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法

在这里插入图片描述

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

3.哈希冲突

对于两个数据元素的关键字字 k i k_i ki​和 K_j(i != j)，有 k i k_i ki​ != k j k_j kj​，但有：Hash( k i k_i ki​) == Hash( k j k_j kj​)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞

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

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

2.开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中,即发生哈希冲突之后，把key直接链接在该位置的下面

二、闭散列

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

1.线性探测

线性探测法是指从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止，比如下面的场景中，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突，则我们可以向后寻找一个空的位置即下标为8 的位置进插入

在这里插入图片描述

下面我们来模拟实现哈希函数的除留余数法，并使用闭散列的线性探测法来解决哈希冲突的问题

2.哈希表的基本框架

哈希表节点结构的定义如下：

#pragma once
#include <vector>

namespace closeHash
{
	// 定义一个位置的状态
	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 Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashData<K, V> Data;
	private:
		vector<Data> _tables;
		size_t _n = 0;  // 表中存储的有效数据的个数
	};
}

为了方便，在哈希表中我们使用vector来存储数据，并增加了一个变量n来记录表中有效数据的个数，同时，哈希表的每一个下标位置存储的数据都是一个KV模型的键值对，此外我们还需要使用一个state变量来记录每一个位置的状态。

原因是因为我们可能是删除哈希表中的数据，但是我们在插入的时候，当key映射的下标位置被占用时，key会向后寻找下一个空的位置进行插入，但是如果key走到数据尾部还没有找到就会从数组的起始位置开始寻找。 假如我们删除了其中的一个节点，此时我们需要查找一个节点，由于被占用的原因该节点在被删除节点的位置的后面，我们一步一步向后找的时候，在走到被删除节点的位置，发现该位置没有数据之后就会返回false，但事实上这个数据是存在的，即使我们说删除之后我们将该位置的数据修改为一个数字，但是选择哪一个呢？0，-1/1都不合适，因为插入的数据是可能的任何数据，但是当我们使用一个state来标识一个位置的状态的时候，我们查找走到已经被删除位置的时候，发现该位置的数据被删除了，但是查找会继续向后进行查找。

所以，在哈希表中每个位置的数据增加了一个state变量类似标记该位置的状态。

3.哈希表的操作

1.哈希表的插入

插入一个分为两步：

1.通过哈希函数获取待插入元素在哈希表中的位置

2.如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

我们插入的时候需要考虑扩容的问题，这个我们在哈希表扩容的时候再进行详细的讲解。

插入代码如下：

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
// 插入
bool Insert(const pair<K, V>& kv)
{
	// 已经存在该值返回false
	if (Find(kv.first))
		return false;

	// 大于标定负载因子，就需要扩容
	if (_n * 10 / _tables.size() > 7)
	{
		// 使用一个新的哈希表，进行插入，然后进行交换两个哈希表的_tables
		HashTable<K, V> newHT;
		newHT._tables.resize(_tables.size() * 2);
		for (auto& e : _tables)
		{
			if (e._state == EXIST)
			{
				newHT.Insert(e._kv);
			}
		}

		_tables.swap(newHT._tables);
	}

	Hash hf;
	size_t hashi = hf(kv.first) % _tables.size();
	while (_tables[hashi]._state == EXIST)
	{
		hashi++;
		hashi %= _tables.size();
	}

	//插入之后将该位置的状态该为存在
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	++_n;

	return true;
}

2.哈希表的查找

通过哈希函数得到余数即数组下标，取出下标位置的key与目标key进行比较，相等就返回该位置的地址，如果查找到状态为空的下标位置就返回nullptr，但是这样有几个需要注意的地方：

1.当遇到状态为空的下标位置才返回nullptr，而不是遇到状态为删除的位置就返回nullptr，因为我们要查找的数据可能在删除数据的后面

2.将查找函数的返回值定义为Data*，而不是bool，这样可以方便我们进行删除和修改(修改key对应的value)，查找到之后直接通过指针的解引用修改value与state

3.哈希表经过不断的插入和删除，最终可能会出现一种极端的情况–哈希表中元素的状态全为EXIST和DELETE，此时如果我们找空就会造成死循环，所以我们需要对这种情况进行单独的处理

// 查找
// 查找返回那个位置的地址
Data* Find(const K& key)
{
	Hash hf;// 仿函数对象
	size_t hashi = hf(key) % _tables.size();
    // 记录hashi的起始位置，避免哈希表中元素全为EXISR和DELETE造成死循环
    size_t starti = hashi;
	while (_tables[hashi]._state != EMPTY)
	{
        // key相等且state为EXIST才表示找到
		if (_tables[hashi]._state == EXIST && _tables[hashi]._kv.first == key)
		{
			return &_tables[hashi];
		}

		++hashi;
		hashi %= _tables.size();
        
        // 如果找了一圈都没有找到，则跳出循环
        if(starti == hashi)
            break;
	}

	return nullptr;
}

3.哈希表的删除

哈希表的删除我们复用查找函数，查到到就通过查找函数的返回值将下标位置数据的状态置为DELETE即可，没有找到就返回false

代码如下：

// 删除
bool Erase(const K& key)
{
	Data* ret = Find(key);
	if (ret)
	{
		// 删除之后将该位置的状态改为删除
		ret->_state = DELETE;
		--_n;
		return true;
	}
	else
	{
		return false;
	}
}

4.哈希表的扩容

哈希表的扩容和普通顺序表容器的扩容不同，它不是容器满了才进行扩容，而是会有一个负载因子，当负载因子 超过一定大小时才会进行扩容，书上对负载因子的表述如下：

在这里插入图片描述

哈希的扩容并不是简单的扩大空间，而是需要将已经插入到哈希表中的元素取出全部重新进行插入，因为扩容后会导致哈希表的长度改变，那么key通过哈希函数映射到的位置也会发生改变，所以需要重新进行插入

我们这里使用一个HashTable对象进行插入，然后交换二者的数组

// 插入
bool Insert(const pair<K, V>& kv)
{
	// 已经存在该值返回false
	if (Find(kv.first))
		return false;

	// 大于标定负载因子，就需要扩容
	if (_n * 10 / _tables.size() > 7)
	{
		// 使用一个新的哈希表，进行插入，然后进行交换两个哈希表的_tables
		HashTable<K, V> newHT;
		newHT._tables.resize(_tables.size() * 2);
		for (auto& e : _tables)
		{
			if (e._state == EXIST)
			{
				newHT.Insert(e._kv);
			}
		}

		_tables.swap(newHT._tables);
	}

	Hash hf;
	size_t hashi = hf(kv.first) % _tables.size();
	while (_tables[hashi]._state == EXIST)
	{
		hashi++;
		hashi %= _tables.size();
	}

	//插入之后将该位置的状态该为存在
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	++_n;

	return true;
}

5.哈希表的仿函数

我们插入的key值不是整数的时候，但是我们要让key与哈希表的长度取模得到映射位置，此时我们就需要进行两次转换，先将其他类型的数据转换成整数，再将该整数作为key转换为下标，比如我们统计水果数量的时候，就需要先将字符串转换为整数作为key值，然后再进行映射。

由于key值可以是不同类型的数据，我们不能只考虑字符串，字符串我们可以选择使用[]的方式获得第一个字符，但是对于其他类型就不再适用了，所以我们需要使用仿函数来帮我们解决这个问题。

我们可以为哈希表增加一个模板参数，给模板参数是一个仿函数，仿函数分为设计者提供的默认的仿函数和用户提供的仿函数，系统默认提供的仿函数可以将一些常见的key的类型全部转换为整形，比如字符串，指针，整数。而用户提供的仿函数则可以根据用户自己的需求将对应的key值转换为整形。

代码如下：

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

// 特化 --针对string类型写一个仿函数--转成整形
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto& ch : key)
		{
			hash *= 131;
			hash += ch;
		}

		return hash;
	}
};

有了仿函数之后，我们只需要在key与TableSize取模的地方使用仿函数对象将key转换为整形即可。这样，对于常见的key类型，哈希表可以通过内置的默认仿函数来完成下标的映射，对于用户自定义的key类型，需要我们自己提供对应的仿函数类来完成下标的映射

6.字符串的哈希算法

哈希表中key值的类型在我们日常生活中运用十分的广泛，我们可以取第一个字符来进行映射，但是这样很容易发生哈希冲突–只要字符串的首字母相同就会发生冲突，我们也可以考虑将字符串的所有字符的ASCII值加起来作为key值进行映射，但是对于这样的字符串–“abc" “acb” “bca” "aad"等等，这样的字符串的ASCII值相等也会发生哈希冲突

所有就有人专门研究看字符串哈希算法，即如何将字符串转换为整形可以使得将哈希冲突率变得很低，下面的一篇博客介绍了许多优秀非字符串哈希算法，我们可以借鉴学习学习：各种字符串Hash-clq-博客园(cnblogs.com)

其中BKDR哈希字符串算法是最出名也是平均分最高的，上面我们的代码中字符串算法就是使用的该算法

7.完整代码

这里我们需要注意的是，哈希表的拷贝构造，析构，赋值重载使用我们编译器默认生成的即可–对于自定义类型编译器会调用自定义类型的拷贝构造，析构和赋值重载，由于table是vector类型的成员变量，而vector中实现了深拷贝与析构，所以不需要我们自己来实现

HashTable.h

#pragma once

#include <vector>

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

// 特化 --针对string类型写一个仿函数--转成整形
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto& ch : key)
		{
			hash *= 131;
			hash += ch;
		}

		return hash;
	}
};

namespace closeHash
{
	// 定义一个位置的状态
	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 Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashData<K, V> Data;
	public:
		// 默认构造
		HashTable()
			:_n(0)
		{
			_tables.resize(10);
		}

		// 插入
		bool Insert(const pair<K, V>& kv)
		{
			// 已经存在该值返回false
			if (Find(kv.first))
				return false;

			// 大于标定负载因子，就需要扩容
			if (_n * 10 / _tables.size() > 7)
			{
				// 使用一个新的哈希表，进行插入，然后进行交换两个哈希表的_tables
				HashTable<K, V> newHT;
				newHT._tables.resize(_tables.size() * 2);
				for (auto& e : _tables)
				{
					if (e._state == EXIST)
					{
						newHT.Insert(e._kv);
					}
				}

				_tables.swap(newHT._tables);
			}

			Hash hf;
			size_t hashi = hf(kv.first) % _tables.size();
			while (_tables[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}

			//插入之后将该位置的状态该为存在
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;

			return true;
		}

		// 查找
// 查找返回那个位置的地址
		Data* Find(const K& key)
		{
			Hash hf;// 仿函数对象
			size_t hashi = hf(key) % _tables.size();
			// 记录hashi的起始位置，避免哈希表中元素全为EXISR和DELETE造成死循环
			size_t starti = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				// key相等且state为EXIST才表示找到
				if (_tables[hashi]._state == EXIST && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}

				++hashi;
				hashi %= _tables.size();

				// 如果找了一圈都没有找到，则跳出循环
				if (starti == hashi)
					break;
			}

			return nullptr;
		}

		// 删除
		bool Erase(const K& key)
		{
			Data* ret = Find(key);
			if (ret)
			{
				// 删除之后将该位置的状态改为删除
				ret->_state = DELETE;
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<Data> _tables;
		size_t _n = 0;  // 表中存储的有效数据的个数
	};
}

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;

#include "HashTable.h"


void TestHT1()
{
	closeHash::HashTable<int, int> ht;
	int a[] = { 18, 8, 7, 27, 57, 3, 38, 18 };
	for (auto e : a)
	{
		ht.Insert(make_pair(e, e));
	}

	ht.Insert(make_pair(17, 17));
	ht.Insert(make_pair(5, 5));

	cout << ht.Find(7) << endl;
	cout << ht.Find(8) << endl;

	ht.Erase(7);
	cout << ht.Find(7) << endl;
	cout << ht.Find(8) << endl;
}

void TestHT2()
{
	string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

	//HashTable<string, int, HashFuncString> countHT;
	closeHash::HashTable<string, int> countHT;
	for (auto& e : arr)
	{
		closeHash::HashData<string, int>* ret = countHT.Find(e);
		if (ret)
		{
			ret->_kv.second++;
		}
		else
		{
			countHT.Insert(make_pair(e, 1));
		}
	}

	HashFunc<string> hf;
	cout << hf("abc") << endl;
	cout << hf("bac") << endl;
	cout << hf("cba") << endl;
	cout << hf("aad") << endl;
}
int main()
{
	//TestHT1();
	TestHT2();
	return 0;
}

8.二次探测

线性探测优点：实现非常简单，

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

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： H i H_i Hi​ = ( H 0 H_0 H0​ + i 2 i^2 i2 )% m,或者： H i H_i Hi​ = ( H 0 H_0 H0​ - i 2 i^2 i2 )% m。其中：i =1,2,3…， H 0 H_0 H0​是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置，m是表的大小。即根据余数找到下标位置，如果位置被占用，不是去挨着的下一个位置找，而是去余数+i的平方的位置找插入位置，其中i是寻找的次数

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容

比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷.最后二次探测法在一定程度上减轻了哈希冲突的概率，但也没有从根源上解决问题。

三、开散列

1.开散列概念

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

即在发生哈希冲突的时候，把key作为一个节点直接链接在对应下面位置的哈希桶

在这里插入图片描述

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

2.开散列的节点结构

由于开散列的不同冲突的元素之间不会相互影响，所以开散列不再需要status变量来记录每一个下面位置的状态，此外开散列的每个下标位置链接的都是一个哈希桶，所以vector中的每一个元素都是一个节点的指针，指向单链表中的第一个元素，所以_tables是一个指针数组，这样就不会去占用别人的位置，所以不管在插入还是查找方面，开散列都要比闭散列要更加的高效，所以C++STL中的unordered_set和unordered_map以及Java中的HashSet和HashMap的底层都是使用哈希表的开散列方式实现的。最后，为了使得不同类型的key都能够计算出其映射的下标位置，所以我们需要传递一个仿函数：

// 仿函数
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{

		return (size_t)key;
	}
};

// 特化 --针对string类型写一个仿函数--转成整形
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}

		return hash;
	}
};
// 哈希表达节点结构--单链表
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 Hash=HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
private:
	vector<Node*> _tables; //指针数组
	size_t _n;// 表中有效数据的个数
};

3.开散列的操作

1.开散列的插入

开散列插入和闭散列一样，首先需要根据key值与哈希表的大小得到映射的下标的位置，此外，由于哈希表中每个下标位置都是一个哈希桶，即一个单链表，那么我们插入的时候只需要将冲突的元素链接到哈希桶中即可。这里链接有两种方式：

1.将发生哈希冲突的元素链接到单链表的末尾，即尾插

2.将发生哈希冲突的元素链接到单链表的头部，即头插

但是由于单链表尾插需要从头结点开始遍历进行找尾，这样插入的效率就比较低，所以我们选择头插的方式

插入部分代码如下：

bool Insert(const pair<K, V>& kv)
{
    if (Find(kv.first))
			return false;
    //调用仿函数的匿名对象将key转换为整数
    size_t hashi = Hash()(kv.first) % _tables.size();
	// 头插
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;

	++_n;

	return true;
}

2.开散列的查找

开散列的查找只需要根据取模得到下标，由于下标位置存储的是单链表首元素的地址，我们进行遍历即可

Node* Find(const K& key)
{
    size_t hashi = Hash()(key) % _tables.size();
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			return cur;
		}
		else
		{
			cur = cur->_next;
		}
	}

	return nullptr;
}

3.开散列的删除

和闭散列不同的是，开散列的删除不能直接通过查找函数的返回值进行删除，因为单链表在删除节点时还需要改变父节点的指向，让其指向下一个节点，和单链表的删除相同，所以我们需要遍历单链表找到删除的节点进行删除

bool Erase(const K& key)
{
    // 通过哈希映射站到下标位置
	size_t hashi = Hash()(key) % _tables.size();
    
	Node* prev = nullptr;
	Node* cur = _tables[hashi];

	while (cur)
	{
		if (cur->_kv.first == key)
		{
			// 头删
			//if (prev == nullptr)
			if(cur == _tables[hashi])
			{
				//_tables[hashi] = nullptr;
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}

			delete cur;
			--_n;

			return true;
		}
		else
		{
			cur = cur->_next;
			prev = cur;
		}
	}

	return false;
}

4.开散列的扩容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

开散列最好的情况是每一个哈希桶中都只有一个元素，再继续插入元素的时候，每一次就会发生哈希冲突，因此，我们可以在元素的个数等于桶的个数的时候进行扩容，即负载因子为1

这样我们可以采用两种扩容的方式:

1.采用闭散列扩容的思路-通过复用insert函数来进行扩容，但是开散列每个插入的时候都需要新开辟节点，在插入完毕之后，我们还需要释放表中原来的节点，这样就会使得效率很低

2.我们可以创建一个vector，取出旧表中的每一个节点链接到新的表中，然后再交换旧表和新表，这样就没有开辟节点和释放节点的消耗了，从而大大提高了扩容的效率。注：我们不能直接将原表中的整个哈希桶链接到新表中，因为新表的大小改变后原表中的元素可能会映射到表的其他位置

所以开散列的析构函数需要我们自己实现，因为默认生成的析构函数不会释放掉哈希桶

我们每次扩容不一定都在扩容2倍，有人提出了表的大小为质数 的时候哈希冲突的概率会低一些，当使用质数作为除数时，能够更加均匀地散列key值，就会较少哈希冲突的发生。库中可以这样实现的，但是也不是必须的，所以我们这里使用一个数组，保存一组质数，大概是2倍的关系，但是在42亿之后就不会再进行扩容了，其实我们也不用担心，因为我们整数的数据一共才42亿，是可以存储得下的。

但是在某一些极端场景下，或者面对某些碰撞攻击时(对方知道我们好像表的长度以及取模的逻辑，这个时候就专门设计一些冲突的数据，使得效率就不变得很低)，那么机会导致单链表的长度过长，从而降低哈希的查找与删除的效率。

为了应对这种情况，Java 8中使用的HashMap在使用红黑树来优化哈希冲突的情况，因为红黑树可以保证查找，插入和删除的时间复杂度为O(logN)，效率就会比链表快很多，此外，C++11也引入了一个新的数据结构–开发定址哈希表(open addressing table)，用于存储哈希冲突时的元素，开放定址哈希表是一种不使用链表来解决哈希冲突的实现方式。这种实现方式中，如果一个槽(slot)已经被占用了，就会尝试找到下一个可用的槽，直达找到一个空槽，因为开发地址哈希表可以更好的利用缓冲，从而提高查找性能。C++11之后的版本中，unordered_map的哈希桶使用了两种不同的数据结构，包括单链表和开放定址哈希表–当桶中元素较少时，使用链表，当桶的元素较多的时候，会自动转换为开放定址哈希表

STL源码中的实现：

// Note: assumes long is at least 32 bits.
static const int __stl_num_primes = 28;
static const unsigned long __stl_prime_list[__stl_num_primes] =
{
  53,         97,         193,       389,       769,
  1543,       3079,       6151,      12289,     24593,
  49157,      98317,      196613,    393241,    786433,
  1572869,    3145739,    6291469,   12582917,  25165843,
  50331653,   100663319,  201326611, 402653189, 805306457, 
  1610612741, 3221225473, 4294967291
};

inline unsigned long __stl_next_prime(unsigned long n)
{
  const unsigned long* first = __stl_prime_list;
  const unsigned long* last = __stl_prime_list + __stl_num_primes;
  const unsigned long* pos = lower_bound(first, last, n);
  return pos == last ? *(last - 1) : *pos;
}

扩容代码如下：

// 负载因子控制在1，超过就扩容
if (_tables.size() == _n)
{
	 创建一个哈希表对象，然后进行插入，之后交换双方的vector
	//HashTable<K, V> newHT;
	//newHT._tables.resize(_tables.size() * 2);
	//for (size_t i = 0; i < _tables.size(); ++i)
	//{
	//	Node* cur = _tables[i];
	//	while (cur)
	//	{
	//		newHT.Insert(cur->_kv);
	//		cur = cur->_next;
	//	}
	//}

	//_tables.swap(newHT._tables);

	vector<Node*> newTables;
	//newTables.resize(_tables.size() * 2, nullptr);
	newTables.resize(__stl_next_prime(_tables.size()), nullptr);
	for (size_t i = 0; i < _tables.size(); ++i)
	{
		Node* cur = _tables[i];
		while (cur)
		{
			// 保存下一个节点
			Node* next = cur->_next;
			size_t hashi = Hash()(cur->_kv.first) % newTables.size();
			//进行头插
			cur->_next = newTables[i];
			newTables[i] = cur;

			cur = next;
		}

		_tables[i] = nullptr;
	}

	_tables.swap(newTables);
}

5.开散列完整代码实现

namespace buckethash
{
	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 Hash=HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		// 构造
		HashTable()
			:_n(0)
		{
			_tables.resize(__stl_next_prime(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] = nullptr;
			}
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			// 负载因子控制在1，超过就扩容
			if (_tables.size() == _n)
			{
				 创建一个哈希表对象，然后进行插入，之后交换双方的vector
				//HashTable<K, V> newHT;
				//newHT._tables.resize(_tables.size() * 2);
				//for (size_t i = 0; i < _tables.size(); ++i)
				//{
				//	Node* cur = _tables[i];
				//	while (cur)
				//	{
				//		newHT.Insert(cur->_kv);
				//		cur = cur->_next;
				//	}
				//}

				//_tables.swap(newHT._tables);

				vector<Node*> newTables;
				//newTables.resize(_tables.size() * 2, nullptr);
				newTables.resize(__stl_next_prime(_tables.size()), nullptr);
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						// 保存下一个节点
						Node* next = cur->_next;
						size_t hashi = Hash()(cur->_kv.first) % newTables.size();
						//进行头插
						cur->_next = newTables[i];
						newTables[i] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = Hash()(kv.first) % _tables.size();
			// 头插
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

			++_n;

			return true;
		}

		Node* Find(const K& key)
		{
			size_t hashi = Hash()(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				else
				{
					cur = cur->_next;
				}
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			size_t hashi = Hash()(key) % _tables.size();

			Node* prev = nullptr;
			Node* cur = _tables[hashi];

			while (cur)
			{
				if (cur->_kv.first == key)
				{
					// 头删
					//if (prev == nullptr)
					if(cur == _tables[hashi])
					{
						//_tables[hashi] = nullptr;
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;
					--_n;

					return true;
				}
				else
				{
					cur = cur->_next;
					prev = cur;
				}
			}

			return false;
		}

		inline unsigned long __stl_next_prime(unsigned long n)
		{
			static const int __stl_num_primes = 28;
			static const unsigned long __stl_prime_list[__stl_num_primes] =
			{
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};

			for (int i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > _n)
				{
					return __stl_prime_list[i];
				}
			}

			return __stl_prime_list[__stl_num_primes - 1];
		}

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

6.开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <=0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

椿融雪
关注
  • 28
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 38
    评论
专栏目录
力扣34在排序数组中查找元素的第一个和最后一个位置(二分法哈希表法)
BadSheepC
07-05 295
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。 思路：数组时有序的，所以可以使用二分法，在区间[i，j]中找到target第一次出现的位置(左边界)，和最后一次出现的位置(右边界) 左边界：由于是有序数组，从
哈希表冲突
chengxuzx的博客
11-24 784
哈希表是啥子？ 1、哈希表其实也叫散列表，两个是一个玩意，英文是Hash Table 2、哈希表是一个数据结构 哈希冲突 当有两个不同key值经过哈希函数计算后，得到同一个下标，那么它们就存在在同一个桶里，那么就会产生哈希冲突。实际中冲突是不可避免的，只能通过改进哈希函数的性能来减少冲突。 解决哈希冲突的方法 1.开放寻址法 简单来说，就是当你的位置被占了之后，你就只能再另换位置，那就可以看下一位（下一个桶）是否被占，如果没有就存在这个桶中，如果被占，那就再查找...
哈希表及哈希冲突的解决
Roy_396的博客
07-12 667
哈希表（也叫关联数组）一种通用的数据结构，哈希表是一种通过关键码去寻找值得数据映射结构 例：新华字典。如果我想知道“按”的详细信息，根据拼音去查找拼音索引，首先查找"an"在字典中的位置，如图所示，就会找到“安”，这个过程就是键码映射，通过key去查找f(key)。其中，安就是关键字（key），f（）就是字典索引，也就是哈希函数，查到的页码4就是哈希值。 通过例子可以知道：哈希表是一种通过哈希函数将特定的键映射到特定值的一种数据结构，它维护着键和值之间的一一对应关系。 键(key)：又称为关键字。唯一标识
数据结构：哈希表以及哈希冲突的解决方案
09-08 5089
前言 基于先前的学习计划，最近打算深入学习Java的集合类，首先要研究的就是HashMap，在学习HashMap前，我花了几天时间温习了一下类中用到的数据结构 （哈希表，二叉树），并决定把所学的知识记录写成文章，本文讲述的就是关于哈希表的知识。 什么是哈希表 在之前的博客文章里，我们简单介绍了数据结构的几种分类，其中就包括哈希表，也称散列表，从根本上来说，一个哈希表包含一个数组，通过特殊...
数据结构之哈希表HashTable实例讲解
青山师
06-06 5262
哈希表 是一种以关联方式存储数据的数据结构，在哈希表中，数据以数组格式存储，其中每个数据值都有自己唯一的索引。如果我们知道所需数据的索引，那么数据的访问就会变得非常快。 所以关键是 找到索引， 而检索 数值关键字 到 索引 的方式就是 哈希（Hashing）。 因此，在这个结构中插入和搜索操作非常快，不管数据的大小。哈希表使用数组作为存储介质，并使用散列技术（就是我们的哈希算法）生成一个索引。 ...
C++ 哈希表
Han同学
02-26 2178
C++哈希表
C++ 哈希
m0_61548909的博客
08-27 2730
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
C++哈希
qq_53413129的博客
06-09 3204
unordered系列关联式容器 unordered_map unordered_map的文档介绍 unordered_set 底层结构 哈希概念 哈希冲突的解决 闭散列： 代码实现 哈希基本结构 插入 查找find 删除 仿函数的应用 开散列 基本结构 插入的实现 查找 删除 Unordered_set/Unordered_set对哈希的封装 封装代码框架： 哈希表的迭代器 【operator*和operator->】 operator++前置++ 迭代器
使用C++哈希表实现的学生信息管理系统
04-02
数据结构课程设计之——使用C++哈希表实现的学生信息管理系统。 编译器选择DevC++ 或者 VS2019都可，按照要求新建文件，运行即可。 一、程序的主要功能 程序分为四个模块： 1.建立哈希表：有三个功能（1）插入一个...
C++哈希表实现.zip
08-20
C++实现哈希表
C++哈希表与六子棋的应用学习代码
03-01
c 哈希表 六子棋（Gomoku，又称为五子棋或连珠）是一个两人对战的策略游戏。在这个游戏中，玩家轮流在棋盘上放置棋子，目标是首先形成一条连续的五个或更多同色棋子的直线（横、竖、斜均可）。 下面是一个简单的六...
c++的哈希表hash
03-18
c
哈希代码C++
05-04
哈希 C++
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 145
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 693
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 753
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 324
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 38
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

椿融雪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值