【C++】哈希表的实现

前言

接着【C++】STL容器----unordered_map和unordered_set的使用详情请点击，今天继续介绍【C++】哈希表的实现

一、哈希概念

哈希(hash)又称散列，是一种组织数据的方式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建立一个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进行快速查找

直接定址法

当关键字的范围比较集中时，直接定址法就是非常简单高效的方法，比如一组关键字都在[0,99]之间，那么我们开一个100个数的数组，每个关键字的值直接就是存储位置的下标。再比如一组关键字值都在[a,z]的小写字母，那么我们开⼀个26个数的数组，每个关键字acsii码-a ascii码就是存储位置的下标。也就是说直接定址法本质就是用关键字计算出一个绝对位置或者相对位置。下面我们来看一道leetcode题目点击跳转来使用直接定址法

cpp 复制代码

class Solution {
public:
    int firstUniqChar(string s) 
    {
        int firstUniqChar[26] = {0};
        int size = s.size();
        for(auto ch : s)
        {
            firstUniqChar[ch - 'a']++;     
        }
        for(int i = 0; i < size; ++i)
        {
            if(firstUniqChar[s[i] - 'a'] == 1)
                return i;
        }
        return -1;
    }
};

将关键字转为整数
我们将关键字映射到数组中位置，一般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，如上面leetcode编程题一样，将字母转化成整数。
哈希函数
一个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个方向去考量设计

二、哈希冲突

直接定址法的缺点也非常明显，当关键字的范围比较分散时，就很浪费内存甚至内存不够用。
假设我们只有数据范围是[0, 9999]的N个值，我们要映射到一个M个空间的数组中(⼀般情况下M>=N)，那么就要借助哈希函数(hash function)hf，关键字key被放到数组的h(key)位置，这里要注意的是h(key)计算出的值必须在[0,M)之间。这里存在的一个问题就是，两个不同的key可能会映射到同一个位置去，这种问题我们叫做哈希冲突，或者哈希碰撞。（下面以除法散列法来为例）
理想情况是找出一个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的，所以我们尽可能设计出优秀的哈希函数，减少冲突的次数，同时也要去设计出解决冲突的方案

除法散列法/除留余数法

除法散列法也叫做除留余数法，顾名思义，假设哈希表的大小为M，那么 key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key) = key % M（这里不同的数除以M的余数就有可能会导致余数相同）。
当使用除法散列法时，要尽量避免M为某些值，如2的幂，10的幂等。如果是2 ^ X ，那么key%2 ^ X本质相当于保留key的后X位，那么后x位相同的值，计算出的哈希值都是一样的，就冲突了。如：{63,31}看起来没有关联的值，如果M是16，也就是 2 ^ 4，那么计算出的哈希值都是15，因为63的二进制后8位是00111111，31的二进制后8位是00011111。如果是10 ^ X ，就更明显了，保留的都是10进值的后X位，如：{112,12312}，如果M是100，也就是10 ^ 2，那么计算出的哈希值都是12。
当使用除法散列法时，建议M取不太接近2的整数次幂的⼀个质数(素数)（11， 13等）。

乘法散列法（了解）

乘法散列法对哈希表大小M没有要求，他的大思路：

第一步：用关键字K乘上常数A(0<A<1)：A取黄金分割点比较好，并抽取出k*A的小数部分。

第二步：后再用M乘以k*A的小数部分，再向下取整

全域散列法（了解）

如果存在⼀个恶意的对手，他针对我们提供的散列函数，特意构造出一个发生严重冲突的数据集，比如，让所有关键字全部落入同一个位置中。这种情况是可以存在的，只要散列函数是公开且确定的，就可以实现此攻击 。解决方法自然是见招拆招，给散列函数增加随机性 ，攻击者就无法找出确定可以导致最坏情况的数据。这种方法叫做全域散列
h(key) = ((a × key + b) % P) % M,P需要选⼀个足够大的质数，a可以随机选 [1,P-1]之间的任意整数，b可以随机选 [0,P-1]之间的任意整数，这些函数构成了一个P*(P-1)组全域散列函数组

处理哈希冲突

实践中哈希表一般还是选择除法散列法 作为哈希函数，当然哈希表无论选择什么哈希函数也避免不了冲突，那么插入数据时，如何解决冲突呢？主要有两种方法，开放定址法和链地址法

铺垫知识：负载因子

假设哈希表中已经映射存储了N个值，哈希表的大小为M，那么负载因子 = N / M。负载因子越大，哈希冲突的概率越高 ，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低

开放定址法

在开放定址法中所有的元素都放到哈希表里，当一个关键字key用哈希函数计算出的位置冲突 了，则按照某种规则找到一个没有存储数据的位置进行存储，开放定址法中负载因子一定是小于1的。

这里的规则有三种：线性探测、⼆次探测、双重探测。

线性探测

从发生冲突的位置开始，依次线性向后探测，直到寻找到下一个没有存储数据的位置为止，如果走到哈希表尾，则回绕到哈希表头的位置
h(key) = hash0 = key % M，hash0位置冲突了，则线性探测公式为：hc(key,i) = hashi = (hash0 + i) % M, i = {1,2,3...M-1}，因为负载因子小于1，则最多探测M-1次，一定能找到一个存储key的位置

下面演示 {19,30,5,36,13,20,21,12} 等这一组值映射到M=11的表中：

h(19) = 8 、h(30) = 8 ；h(5) = 5；h(36) = 3；h(13) = 2 ；h(20) = 9 ；h(21) = 10；h(12) = 1 ；

二次探测

从发生冲突的位置开始，依次左右按二次方跳跃式探测，直到寻找到下一个没有存储数据的位置为止，如果往右走到哈希表尾，则回绕到哈希表头的位置；如果往左走到哈希表头，则回绕到哈希表尾的位置；
h(key) = hash0 = key % M，hash0位置冲突了，则二次探测公式：hc(key,i) = hashi = (hash0 + i^2) % M, i = {1,2,3...M/2}
二次探测当hashi = (hash0 - i ^ 2) % M时，当hashi<0时，需要hashi += M

双重散列（了解）

第一个哈希函数计算出的值发生冲突，使用第二个哈希函数计算出一个跟key相关的偏移量值，不断往后探测，直到寻找到下⼀个没有存储数据的位置为止

开放定址法代码实现

开放定址法在实践中，不如下面讲的链地址法，因为开放定址法解决冲突不管使用哪种方法，占用的都是哈希表中的空间，始终存在互相影响的问题。所以开放定址法我们简单选择线性探测实现即可。
如下图所示当我们查找、插入、删除某个数据时，需要一个状态量 来判断每个位置后面是否还有数据，要不然即使遍历到空节点我们也不敢说后面没有数据（该数据不存在）
用枚举来实现状态量的表示，一个vector数组中存入的是一个个HashData，包括数据和状态量

cpp 复制代码

enum State
{
	EXIST,
	EMPTY,
	DELETE
};

template<class K,class V>
struct HashData
{
	pair <K, V> _kv;
	State _state = EMPTY;
};

template<class K, class V>
class HashTable
{
public:
	HashTable()
		:_tables(11)
		,_n(0)
	{}
private:
	vector<HashData<K, V>> _tables;
	size_t _n = 0;
};

insert

插入一个pair结构的数据
h(key) = hash0 = key % M，这里的M是vector的size()，还是vector的capacity()呢？M是vector的size()，假如我们将vector初始化11个节点数据都是{0，0}，size = 11，这个时候如果capacity为20，key % capacity = 15，但是15下标越界了
所以key % M中，M是vector的size()而不是capacity

cpp 复制代码

bool Insert(const pair<K, V>& kv)
{
	size_t hash0 = kv.first % _tables.size();
	size_t hashi = hash0;
	size_t i = 1;
	while (_tables[hashi]._state == EXIST)
	{
		hashi = (hashi + i) % _tables.size();
		++i;
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	++_n;
}

cpp 复制代码

void TestHT()
{
	int a[] = { 19, 30, 5, 36, 13, 20, 21, 12 };
	HashTable<int, int> ht;
	for (auto& e : a)
	{
		ht.Insert({ e, e });
	}
}
int main()
{
	TestHT();
	return 0;
}

Find

查找的逻辑：当某个节点的状态不等于EMPTY，进入循环判断是否等于key值且状态不等于DELETE，等于key且状态不等于DELETE则返回节点地址
否则返回false

cpp 复制代码

HashData<K, V>* Find(const K& key)
{
	size_t hash0 = key % _tables.size();
	size_t hashi = hash0;
	size_t i = 1;
	while (_tables[hashi]._state != EMPTY)
	{
		if (_tables[hashi]._kv.first == key && _tables[hashi]._state != DELETE)
		{
			return &_tables[hashi];
		}
		hashi = (hashi + i) % _tables.size();
		++i;
	}
	return nullptr;
}

Erase

删除hash节点通过复用Find，找到节点地址，如果不为空，则将其状态改为 DELETE

cpp 复制代码

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

上面的Insert代码展示的是一个简单的插入操作，因为真实插入还要考虑vector容量满了之后的扩容操作
扩容：
一般不会说等vector满了之后才去扩容，这里通过负载因子（0.7负载因子开始扩容）
我们将HashTable的构造函数传入一个缺省值size，用size初始化_tables

cpp 复制代码

HashTable(size_t size = 11)
	:_tables(size)
	,_n(0)
{}

扩容我们创建一个新的HashTable newHT，并初始化_tables为原来_tables.size() 的2倍，遍历原_tables的状态量，如果是存在则将其插入新hash表中，最后交换新旧hash表。
这里我们新建一个HashTable而不是vector数组原因是：如果新建一个vector，将vector扩容为原来的两倍，但是在将原来vector存在数据放到新的vector中，我们需要重新计算数据要插入到哪个位置中；如果是新建的 HashTable，那么我们复用Insert代码，直接就插入到新HashTable的对应位置

cpp 复制代码

bool Insert(const pair<K, V>& kv)
{
	//负载因子0.7就开始扩容
	if ((double)_n / (double)_tables.size() >= 0.7)
	{
		HashTable<K, V> newHT(_tables.size() * 2);
		for (size_t i = 0; i < _tables.size()； i++)
		{
			if (_tables[i]._state == EXIST)
			{
				newHT.Insert(_tables[i]._kv);
			}
		}
		_tables.swap(newHT_tables);
	}

对于扩容大小问题，除法散列表建议M是质数，如果我们扩容大小扩到原来_tables.size() 的2倍，那么就不是一个质数了，我们现在看看源码是怎么处理扩容这个问题的
__stl_prime_list[__stl_num_primes]是一个素数表（几乎是2倍关系）
还提供了一个内联函数，作用是取大于等于n的素数表的素数

cpp 复制代码

// 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;
}

我们参考使用源代码逻辑，初始化给__stl_next_prime内联函数传入0，则素数表的第一个大小：53来初始化_tables的size；后面扩容时传入_tables.size() + 1，这样扩容的大小一定是素数表中比size大的那个素数

cpp 复制代码

HashTable(size_t size = __stl_next_prime(0))
	:_tables(size)
	,_n(0)
{}
bool Insert(const pair<K, V>& kv)
{
	//负载因子0.7就开始扩容
	if ((double)_n / (double)_tables.size() >= 0.7)
	{
		//HashTable<K, V> newHT(_tables.size() * 2);
		HashTable<K, V> newHT(__stl_next_prime(_tables.size() + 1));
		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 hash0 = kv.first % _tables.size();
	size_t hashi = hash0;
	size_t i = 1;
	while (_tables[hashi]._state == EXIST)
	{
		hashi = (hashi + i) % _tables.size();
		++i;
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	++_n;
	return true;
}

测试：我们插入100个值来验证扩容机制和插入问题

cpp 复制代码

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

从结果看到初始化以及扩容机制都是正确的

key不能取模的问题

当key是string/Date/double等类型时，key不能取模 （负数取模还是负数），那么我们需要给HashTable增加一个仿函数
这个仿函数支持把key转换成一个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现一个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。

cpp 复制代码

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

string做哈希表的key非常常见，所以我们可以考虑把string特化一下，string可能字母都相同，只是顺序不一样（例如："abc"，"bca"），那么初版代码会导致两个string最后产生冲突；所以我们将每个字符乘以一个种子值（或者质数），这样更不容易冲突(比如日期类的年月日，也是同样的处理办法来尽量避免冲突)

cpp 复制代码

//初版
struct HashFuncString
{
	size_t operator()(const string& key)
	{
		size_t hashi = 0;
		for (auto& ch : key)
		{
			hashi += ch;
		}
		return hashi;
	}
};
//终版
struct HashFuncString
{
	size_t operator()(const string& key)
	{
		size_t hashi = 0;
		for (auto& ch : key)
		{
		    hashi *= 131;
			hashi += ch;
		}
		return hashi;
	}
};

三、链地址法（重点）

开放定址法中所有的元素都放到哈希表里，链地址法 中所有的数据不再直接存储在哈希表中，哈希表中存储⼀个指针 ，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶

下面演示 {19,30,5,36,13,20,21,12,24,96} 等这一组值映射到M=11的表中，h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) = 10，h(12) = 1,h(24) = 2,h(96) = 8
我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下面，如果一个哈希表位置下面挂了很多链表，会将其转换为红黑树（一般情况下不会需要转换成红黑树），哈希表指针指向红黑树

哈希桶代码实现

哈希桶的代码实现也叫HashTable，为了和上面的开放定址法代码中的命名不产生冲突，我们将者两种方法都使用命名空间隔离，开放定址法----open_address；哈希桶----hash_bucket
实现哈希桶，我们需要定义哈希节点，哈希数组vector中都是一个一个的哈希节点，_n还是表示插入数据的实际个数
同样初始化时使用stl库的素数表和内联函数来进行vector的初始化

cpp 复制代码

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:
		HashTable(size_t size = __stl_next_prime(0))
		:_tables(size, nullptr)
  		{}
	private:
		vector<Node*> _tables; //指针数组
		size_t _n = 0;
	};
};

Insert

哈希桶插入没有因为冲突需要探测，所以只需要找到插入位置然后头插即可
扩容和开放定址法一样的逻辑，这里的负载因子可以大一点（这里将负载因子设为1，这样平均每个vector节点下面挂着一个，但实际不会这么均匀，可能有的节点下面有2-3个，有的一个，有的没有；2-3个查找也很方便），因此设为1是合理的（此方法不是最佳方法）

cpp 复制代码

bool Insert(const pair<K, V>& kv)
{
	//负载因子为1再扩容
	if (_n == _tables.size())
	{
		HashTable<K, V> newHT(__stl_next_prime(_tables.size() + 1));
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				newHT.Insert(cur->_kv);
				cur->_next;
			}
		}
		_tables.swap(newHT._tables);
	}
	size_t hashi = kv.first % _tables.size();

	//头插
	Node* newnode = new Node(kv);

	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
}

上面扩容的方法，在找到一个节点之后将其插入到新节点的位置的时候，我们新new了一个节点再来插入，后面节点还需要自行写析构函数来析构，这样代码是很大的
我们可以直接将原节点直接插入到新的表中，而不是再去new一个节点再插入

cpp 复制代码

bool Insert(const pair<K, V>& kv)
{
	//负载因子为1再扩容
	if (_n == _tables.size())
	{
		vector<Node*> newtables(__stl_next_prime(_tables.size() + 1), nullptr);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				//旧表节点拿下来，插入到新表的位置
				Node* next = cur->_next;

				size_t hashi = cur->_kv.first % newtables.size();
				cur->_next = newtables[hashi];
				newtables[hashi] = cur;

				cur = next;
			}
			_tables[i] = nullptr;
		}

		_tables.swap(newtables);
	}
	
	size_t hashi = kv.first % _tables.size();

	//头插
	Node* newnode = new Node(kv);

	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

Find

哈希桶的查找我们只需要找到key所在位置，然后遍历这个位置下面的所有节点，如果相等则返回这个节点，不相等则返回nullptr

cpp 复制代码

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

逻辑上不插入相同的值，所以插入前进行检查，没有该值则再进行插入

cpp 复制代码

if (Find(kv.first))
	return false;

Erase

由于哈希桶是一个单链表，因此当我们找到要删除节点时，不能直接删除，而是要找到它的前驱节点，将其前驱节点和后驱节点链接起来，再删除释放该节点
下图展示了删除节点的两种情况，如果pre为空，则让_tables[hashi] = cur->_next，不为空，则prev->_next = cur->_next；再删除cur节点（delete）

cpp 复制代码

bool Erase(const K& key)
{
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	Node* prev = nullptr;
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (prev == nullptr)
			{
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			--_n;
			delete cur;
			return true;
		}
		prev = cur;
		cur = prev->_next;
	}
	return nullptr;
}

析构函数

因为hash桶中有Node* 节点（自定义结构），需要我们写析构函数来释放节点资源

cpp 复制代码

~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;
	}
}

key不能取模的问题

和开放定址法一样需要考虑key不能取模问题，一样的解决思路----使用仿函数

cpp 复制代码

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

四、源码

源码链接，点击查看

【C++】哈希表的实现

目录

前言

一、哈希概念

直接定址法

二、哈希冲突

除法散列法/除留余数法

乘法散列法（了解）

全域散列法（了解）

处理哈希冲突

铺垫知识：负载因子

开放定址法

线性探测

二次探测

双重散列（了解）

开放定址法代码实现

insert

Find

Erase

key不能取模的问题

三、链地址法（重点）

哈希桶代码实现

Insert

Find

Erase

析构函数

key不能取模的问题

四、源码