unordered_map和unordered_set的使用以及哈希表的实现

最新推荐文章于 2025-12-19 16:22:21 发布

原创最新推荐文章于 2025-12-19 16:22:21 发布 · 975 阅读

34 ·

CC 4.0 BY-SA版权

文章标签：

#散列表 #哈希算法 #数据结构 #c++

C++ 专栏收录该内容

31 篇文章

订阅专栏

1. unordered系列的使用

1.1 unordered_set类的介绍

unordered_set的声明如下，Key就是unordered_set底层关键字的类型
unordered_set默认要求Key⽀持转换为整形，如果不⽀持或者想按⾃⼰的需求⾛可以⾃⾏实现⽀持将Key转成整形的仿函数传给第⼆个模板参数
unordered_set默认要求Key⽀持⽐较相等，如果不⽀持或者想按⾃⼰的需求⾛可以⾃⾏实现⽀持将Key⽐较相等的仿函数传给第三个模板参数
unordered_set底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第四个参数。
⼀般情况下，我们都不需要传后三个模板参数
unordered_set底层是⽤哈希桶实现，增删查平均效率是O(1)，迭代器遍历不再有序，为了跟set区分，所以取名unordered_set。
前⾯部分我们已经学习了set容器的使⽤，set和unordered_set的功能⾼度相似，只是底层结构不同，有⼀些性能和使⽤的差异，这⾥我们只讲他们的差异部分。

template < class Key,                     // unordered_set::key_type/value_type      
 		   class Hash = hash<Key>,        // unordered_set::hasher   
		   class Pred = equal_to<Key>,    // unordered_set::key_equal   
		   class Alloc = allocator<Key>   // unordered_set::allocator_type  
		   > class unordered_set;

1.2 unordered_set和set的使用差异

查看⽂档我们会发现unordered_set的⽀持增删查且跟set的使⽤⼀模⼀样，关于使⽤我们这⾥就不再演示了。
unordered_set和set的第⼀个差异是对key的要求不同，set要求Key⽀持⼩于⽐较，⽽unordered_set要求Key⽀持转成整形且⽀持等于⽐较，要理解unordered_set的这个两点要求得后续我们结合哈希表底层实现才能真正理解，也就是说这本质是哈希表的要求。
unordered_set和set的第⼆个差异是迭代器的差异，set的iterator是双向迭代器，unordered_set是单向迭代器，其次set底层是红⿊树，红⿊树是⼆叉搜索树，⾛中序遍历是有序的，所以set迭代器遍历是有序+去重。⽽unordered_set底层是哈希表，迭代器遍历是⽆序+去重。
unordered_set和set的第三个差异是性能的差异，整体⽽⾔⼤多数场景下，unordered_set的增删查更快⼀些，因为红⿊树增删查效率是O(logN)，⽽哈希表增删查平均效率是O(1) ，具体可以参看下⾯代码的演示的对⽐差异。

#include<unordered_set>
#include<set>
#include<iostream>

using namespace std;

void test_set()
{
	const size_t N = 1000000;
	unordered_set<int> us;
	set<int> s;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; ++i)
	{
		//v.push_back(rand()); // N比较大时，重复值比较多
		v.push_back(rand() + i); // 重复值相对少
        //v.push_back(i); // 没有重复，有序
	}

	size_t begin1 = clock();
	for (auto e : v)
	{
		s.insert(e);
	}
	size_t end1 = clock();
	cout << "set insert:" << end1 - begin1 << endl;
    size_t begin2 = clock();
    for (auto e : v)
    {
        us.insert(e);
    }
    size_t end2 = clock();
    cout << "unordered_set insert:" << end2 - begin2 << endl << endl;
    
    int m1 = 0;
    size_t begin3 = clock();
    for (auto e : v)
    {
        auto ret = s.find(e);
        if (ret != s.end())
        {
            ++m1;
        }
    }
    size_t end3 = clock();
    cout << "set find:" << end3 - begin3 << "->" << m1 << endl;
    int m2 = 0;
    size_t begin4 = clock();
    for (auto e : v)
    {
        auto ret = us.find(e);
        if (ret != us.end())
        {
            ++m2;
        }
    }
    size_t end4 = clock();
    cout << "unorered_set find:" << end4 - begin4 << "->" << m2 << endl;
    cout << "插入数据个数：" << s.size() << endl;
    cout << "插入数据个数：" << us.size() << endl << endl;
    
    size_t begin5 = clock();
    for (auto e : v)
    {
        s.erase(e);
    }
    size_t end5 = clock();
    cout << "set erase:" << end5 - begin5 << endl;
    size_t begin6 = clock();
    for (auto e : v)
    {
        us.erase(e);
    }
    size_t end6 = clock();
    cout << "unordered_set erase:" << end6 - begin6 << endl << endl;
}

int main()
{
    test_set();

    return 0;
}

重复值相对少
在这里插入图片描述
N比较大时，重复值比较多

没有重复，有序

我们发现除了有序的情况，unordered_set的增删查效率都比set快的多，而且实际中也很少会给一个有序的序列，所以如果没有特别要求或需要的话建议用unordered系列的容器。

1.3 unordered_map和map的使用差异

查看⽂档我们会发现unordered_map的⽀持增删查改且跟map的使⽤⼀模⼀样，关于使⽤我们这⾥就不再演示了。
unordered_map和map的第⼀个差异是对key的要求不同，map要求Key⽀持⼩于⽐较，⽽unordered_map要求Key⽀持转成整形且⽀持等于⽐较，要理解unordered_map的这个两点要求得后续我们结合哈希表底层实现才能真正理解，也就是说这本质是哈希表的要求。
unordered_map和map的第⼆个差异是迭代器的差异，map的iterator是双向迭代器，unordered_map是单向迭代器，其次map底层是红⿊树，红⿊树是⼆叉搜索树，⾛中序遍历是有序的，所以map迭代器遍历是Key有序+去重。⽽unordered_map底层是哈希表，迭代器遍历是Key⽆序+去重。
unordered_map和map的第三个差异是性能的差异，整体⽽⾔⼤多数场景下，unordered_map的增删查改更快⼀些，因为红⿊树增删查改效率是
O(logN)，⽽哈希表增删查平均效率是 O(1)。

1.4 unordered_multimap/unordered_multiset

unordered_multimap/unordered_multiset跟multimap/multiset功能完全类似，⽀持Key冗余。
unordered_multimap/unordered_multiset跟multimap/multiset的差异也是三个⽅⾯的差异，key的要求的差异，iterator及遍历顺序的差异，性能的差异。

2. 哈希概念

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

2.1 直接定址法

当关键字的范围⽐较集中时，直接定址法就是⾮常简单⾼效的⽅法，⽐如⼀组关键字都在[0,99]之间，那么我们开⼀个100个数的数组，每个关键字的值直接就是存储位置的下标。再⽐如⼀组关键字值都在[a,z]的⼩写字⺟，那么我们开⼀个26个数的数组，每个关键字的acsii码 - a 的ascii码就是存储位置的下标。也就是说直接定址法本质就是⽤关键字计算出⼀个绝对位置或者相对位置。下面是一个利用直接定址法的简单例题。

387. 字符串中的第⼀个唯⼀字符-力扣（LeetCode）

class Solution {
public:
    int firstUniqChar(string s) {
        int count[26] = {0};
        for(auto& e : s)
        {
            count[e - 'a']++;
        }

        for(int i = 0; i < s.size(); i++)
        {
            if(count[s[i] - 'a'] == 1)
                return i;
        }
        return -1;
    }
};

2.2 哈希冲突

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

2.3 负载因子

假设哈希表中已经映射存储了N个值，哈希表的⼤⼩为M，那么负载因⼦= N / M，负载因⼦有些地⽅也翻译为载荷因⼦/装载因⼦等，他的英⽂为load factor。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低；

2.4 将关键字转为整数

我们将关键字映射到数组中的某个位置，⼀般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，这个细节我们后⾯代码实现中再进⾏细节展示。下⾯哈希函数部分，如果关键字不是整数，那么我们讨论的Key是关键字转换成的整数。

2.5 哈希函数

⼀个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个⽅向去考量设计。

2.5.1 除法散列法/除留余数法

除法散列法也叫做除留余数法，顾名思义，假设哈希表的⼤⼩为M，那么通过key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key)=key%M。
当使⽤除法散列法时，要尽量避免M为某些值，如2的幂，10的幂等。如果是2^X ，那么key % 2^X本质相当于保留key的后X位，那么后X位相同的值，计算出的哈希值都是⼀样的，就冲突了。如：{63 , 31}看起来没有关联的值，如果M是16，也就是2^4 ，那么计算出的哈希值都是15，因为63的二进制后4位是1111，31的⼆进制后4位也是1111。如果是10^X，就更明显了，保留的都是10进值的后X位，如：{112,12312}，如果M是100，也就是10^2 ，那么计算出的哈希值都是12。
当使⽤除法散列法时，建议M取不太接近2的整数次幂的⼀个质数(素数)。
需要说明的是，实践中也是⼋仙过海，各显神通，Java的HashMap采⽤除法散列法时就是2的整数次幂做哈希表的⼤⼩M，这样玩的话，就不⽤取模，⽽可以直接位运算，相对⽽⾔位运算⽐模更⾼效⼀些。但是他不是单纯的去取模，⽐如M是2^16次⽅，本质是取后16位，那么⽤key’= key>>16，然后把key和key’异或的结果作为哈希值。也就是说我们映射出的值还是在[0,M)范围内，但是尽量让key所有的位都参与计算，这样映射出的哈希值更均匀⼀些即可。所以我们上⾯建议M取不太接近2的整数次幂的⼀个质数的理论是⼤多数数据结构书籍中写的理论吗，但是实践中，灵活运⽤，抓住本质，⽽不能死读书。（了解）

2.5.2 乘法散列法（了解）

乘法散列法对哈希表⼤⼩M没有要求，他的⼤思路第⼀步：⽤关键字K乘上常数A(0<A<1)，并抽取出K * A的⼩数部分。第⼆步：再⽤M乘以k * A的⼩数部分，再向下取整。
h(key) = floor(M ×((A ×key)%1.0))，其中floor表示对表达式进⾏下取整，A∈(0,1)，这⾥最重要的是A的值应该如何设定，Knuth认为A =( √5 - 1) / 2 = 0.6180339887… (⻩⾦分割点)⽐较好。
乘法散列法对哈希表⼤⼩M是没有要求的，假设M为1024，key为1234，A=0.6180339887,A * key = 762.6539420558，取⼩数部分0.6539420558, M×((A×key)%1.0) = 0.6539420558*1024 = 669.6366651392，那么h(1234) = 669。

2.5.3 全域散列法（了解）

如果存在⼀个恶意的对⼿，他针对我们提供的散列函数，特意构造出⼀个发⽣严重冲突的数据集，⽐如，让所有关键字全部落⼊同⼀个位置中。这种情况是可以存在的，只要散列函数是公开且确定的，就可以实现此攻击。解决⽅法⾃然是⻅招拆招，给散列函数增加随机性，攻击者就⽆法找出确定可以导致最坏情况的数据。这种⽅法叫做全域散列。
h(key) = ((a × key + b) % P) % M，P需要选⼀个⾜够⼤的质数，a可以随机选[1,P-1]之间的任意整数，b可以随机选[0,P-1]之间的任意整数，这些函数构成了⼀个P * (P-1)组全域散列函数组。假设P=17，M=6，a=3，b=4,则h(8) = ((3 × 8 + 4) % 17) % 6 = 5。
需要注意的是每次初始化哈希表时，随机选取全域散列函数组中的⼀个散列函数使⽤，后续增删查改都固定使⽤这个散列函数，否则每次哈希都是随机选⼀个散列函数，那么插⼊是⼀个散列函数，查找⼜是另⼀个散列函数，就会导致找不到插⼊的key了。

2.6 处理哈希冲突

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

2.6.1 开放定址法

在开放定址法中所有的元素都放到哈希表⾥，当⼀个关键字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的位置。
线性探测⽐较简单且容易实现，线性探测的问题：假设hash0位置连续冲突，hash0，hash1，hash2位置已经存储数据了，后续映射到hash0，hash1，hash2，hash3的值都会争夺hash3位置，这种现象叫做群集/堆积。下⾯的⼆次探测可以⼀定程度改善这个问题。
下⾯演示{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
下⾯演示 {19,30,52,63,11,22} 等这⼀组值映射到M=11的表中。

在这里插入图片描述

h(19) = 8, h(30) = 8, h(52) = 8, h(63) = 8, h(11) = 0, h(22) = 0

在这里插入图片描述

双重散列（了解）

第⼀个哈希函数计算出的值发⽣冲突，使⽤第⼆个哈希函数计算出⼀个跟key相关的偏移量值，不断往后探测，直到寻找到下⼀个没有存储数据的位置为⽌。
h1(key) = hash0 = key % M , hash0位置冲突了，则双重探测公式为：hc(key, i) = hashi = (hash0+ i ∗ h2(key)) % M，i = {1,2,3,…, M}
要求h2(key) < M 且h2(key)和M互为质数，有两种简单的取值方法：1、当M为2整数幂时，从[0，M-1]任选⼀个奇数；2、当M为质数时，h2(key) = key % (M − 1) + 1
保证h2(key)与M互质是因为根据固定的偏移量所寻址的所有位置将形成⼀个群，若最⼤公约数 p = gcd(M,h1(key)) > 1，那么所能寻址的位置的个数为M / p < M，使得对于⼀个关键字来说⽆法充分利⽤整个散列表。举例来说，若初始探查位置为1，偏移量为3，整个散列表⼤⼩为12，那么所能寻址的位置为{1,4,7,10}，寻址个数12 / gcd(12,3) = 4
下⾯演示{19,30,52,74} 等这⼀组值映射到M=11的表中，设h2(key) = key % 10 + 1

在这里插入图片描述

2.6.2 开放定址法代码实现

开放定址法在实践中，不如下⾯讲的链地址法，因为开放定址法解决冲突不管使⽤哪种⽅法，占⽤的都是哈希表中的空间，始终存在互相影响的问题。所以开放定址法，我们简单选择线性探测实现即可。

开放定址法的哈希表结构

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 Hash = HashFunc<K>>
class HashTable
{
private:
	vector<HashData<K, V>> _tables;
	size_t _n; // 实际存储数据个数
};

要注意的是这⾥需要给每个存储值的位置加⼀个状态标识，否则删除⼀些值以后，会影响后⾯冲突的值的查找。如下图，我们删除30，会导致查找20失败，当我们给每个位置加⼀个状态标识
{EXIST,EMPTY,DELETE} ，删除30就可以不⽤删除值，⽽是把状态改为DELETE，那么查找20时是遇到EMPTY才结束，这样就可以找到20。

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

在这里插入图片描述

扩容

这⾥我们把哈希表负载因⼦控制在0.7，当负载因⼦到0.7以后我们就需要扩容了，我们还是按照2倍扩容，但是同时我们要保持哈希表⼤⼩是⼀个质数，第⼀个是质数，2倍后就不是质数了。那么如何解决呢？⼀种⽅案就是上⾯2.4.1除法散列中我们讲的JavaHashMap的使⽤2的整数幂，但是计算时不能直接取模的改进⽅法。另外⼀种⽅案是sgi版本的哈希表使⽤的⽅法，给了⼀个近似2倍的质数表，每次去质数表获取扩容后的⼤⼩。

// 素数表
inline unsigned long __stl_next_prime(unsigned long n)
{
	// 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
	};
	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;
}

key不能取模的问题

当key是string / Date等类型时，key不能取模，那么我们需要给HashTable增加⼀个仿函数，这个仿函数⽀持把key转换成⼀个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就⽤默认参数即可，如果这个Key不能转换为整形，我们就需要⾃⼰实现⼀个仿函数传给这个参数，实现这个仿函数的要求就是尽量让key的每个值都参与到计算中，让不同的key转换出的整形值不同。string做哈希表的key⾮常常⻅，所以我们可以考虑把string特化⼀下。

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

// 特化
template<>
struct HashFunc<string>
{
	 // 字符串转换成整形，可以把字符ascii码相加即可
	 // 但是直接相加的话，类似"abcd"和"bcad"这样的字符串计算出的hash是相同的
	// 这⾥我们使⽤BKDR哈希的思路，⽤上次的计算结果去乘以⼀个质数，这个质数⼀般是31, 131等效果会⽐较好
	size_t operator()(const string& key) const
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash += ch;
			hash *= 131;
		}
		return hash;
	}
};

完整代码

// 素数表
inline unsigned long __stl_next_prime(unsigned long n)
{
	// 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
	};
	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;
}

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

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key) const
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash += ch;
			hash *= 131;
		}
		return hash;
	}
};

namespace open_address
{
	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 Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable(size_t n = __stl_next_prime(0))
			:_tables(n)
			, _n(0)
		{
		}

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

			// 扩容，负载因子>=0.7就扩容
			if ((double)_n / (double)_tables.size() >= 0.7)
			{
				HashTable<K, V, Hash> 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);
			}

			Hash hs;
			size_t hash0 = hs(kv.first) % _tables.size();
			size_t hashi = hash0;
			size_t i = 1;
			while (_tables[hashi]._state == EXIST)
			{
				//// 线性探测
				//hashi = (hash0 + i) % _tables.size();
				//++i;

				// 二次探测
				hashi = (hash0 + i * i) % _tables.size();
				++i;
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;

			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hash0 = hs(key) % _tables.size();
			size_t hashi = hash0;
			size_t i = 1;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state == EXIST
					&& _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				//// 线性探测
				//hashi = (hash0 + i) % _tables.size();
				//++i;

				// 二次探测
				hashi = (hash0 + i * i) % _tables.size();
				++i;
			}

			return nullptr;
		}

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

	private:
		vector<HashData<K, V>> _tables;
		size_t _n; // 实际存储数据个数
	};

	void TestHashTable1()
	{
		int a[] = { 19, 30, 5, 36, 13, 20, 21, 12 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert({ e, e });
			//ht.Insert({ 2 * e, e });

		}

		cout << ht.Find(20) << endl;
		cout << ht.Find(30) << endl;
		ht.Erase(30);
		cout << ht.Find(20) << endl;
		cout << ht.Find(30) << endl;

		for (size_t i = 0; i < 100; ++i)
		{
			ht.Insert({ rand(), i });
		}

	}

	struct pairHash
	{
		size_t operator()(const pair<int, int>& kv) const
		{
			size_t hash = 0;
			hash += kv.first;
			hash *= 131;
			hash += kv.second;
			hash *= 131;

			cout << hash << endl;

			return hash;
		}
	};

	void TestHashTable2()
	{
		//HashTable<string, string, StringHashFunc> dict;
		//dict.Insert({ "sort", "排序" });
		//dict.Insert({ "left", "左边" });
		//dict.Insert({ "right", "右边" });

		//StringHashFunc hf;
		//cout << hf("abcd") << endl;
		//cout << hf("bcad") << endl;
		//cout << hf("aadd") << endl;

		//unordered_map<string, string> dict;
		//dict.insert({ "sort", "排序" });
		//dict.insert({ "left", "左边" });
		//dict.insert({ "right", "右边" });

		//HashTable<string, string> dict;
		//dict.Insert({ "sort", "排序" });
		//dict.Insert({ "left", "左边" });
		//dict.Insert({ "right", "右边" });

		unordered_map<pair<int, int>, int, pairHash> um;
		um.insert({ { 1, 3 }, 1 });
		um.insert({ { 3, 1 }, 1 });

	}
}

2.6.3 链地址法

解决哈希冲突的思路

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

下面演示{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) = 88

在这里插入图片描述

扩容

开放定址法负载因⼦必须⼩于1，链地址法的负载因⼦就没有限制了，可以⼤于1。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低；stl中unordered_xxx的最⼤负载因⼦基本控制在1，⼤于1就扩容，我们下⾯实现也使⽤这个⽅式。

极端场景

如果极端场景下，某个桶特别⻓怎么办？其实我们可以考虑使⽤全域散列法，这样就不容易被针对了。但是假设不是被针对了，⽤了全域散列法，但是偶然情况下，某个桶很⻓，查找效率很低怎么办？这⾥在Java8的HashMap中当桶的⻓度超过⼀定阀值(8)时就把链表转换成红⿊树。⼀般情况下，不断扩容，单个桶很⻓的场景还是⽐较少的，下⾯我们实现就不搞这么复杂了，这个解决极端场景的思路，⼤家了解⼀下。

2.6.4 链地址法代码实现

// 素数表
inline unsigned long __stl_next_prime(unsigned long n)
{
	// 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
	};
	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;
}

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

// 特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key) const
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash += ch;
			hash *= 131;
		}
		return hash;
	}
};

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 Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable(size_t n = __stl_next_prime(0))
			:_tables(n, nullptr)
			,_n(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;
			}

			Hash hs;

			// 负载因子到 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;
						// cur头插到新表
						size_t hashi = hs(cur->_kv.first) % newtables.size();
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtables);
			}

			size_t hashi = hs(kv.first) % _tables.size();

			Node* newnode = new Node(kv);
			// 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode; 
			++_n;

			return true;
		}

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

				cur = cur->_next;
			}

			return nullptr;
		}
	
		bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			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 = cur->_next;
			}

			return false;
		}

	private:
		vector<Node*> _tables;
		size_t _n; // 实际存储有效数据个数
	};

	void TestHashTable1()
	{
		int a[] = { 19,30,5,36,13,20,21,12,24,96 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert({ e, e }); 
		}

		for (size_t i = 0; i < 100; ++i)
		{
			ht.Insert({ rand(), i });
		}
	}

	void TestHashTable2()
	{
		int a[] = { 19,30,5,36,13,20,21,12,24,96 };
		HashTable<int, int> ht(11);
		for (auto e : a)
		{
			ht.Insert({ e, e });
		}

		ht.Erase(30);
		ht.Erase(24);

		for (auto e : a)
		{
			ht.Erase(e);
		}
	}

	void TestHashTable3()
	{
		HashTable<string, string> dict;
		dict.Insert({ "sort", "排序" });
		dict.Insert({ "left", "左边" });
		dict.Insert({ "right", "右边" });
	}
}

3. 哈希相关例题

下面关于哈希说法正确的是（）
A.哈希是一种查找的方法，不是数据结构
B.采用哈希方式解决问题时，可以不用哈希函数
C.哈希查找的时间复杂度一定是O(1)
D.哈希是以牺牲空间为代价，提高查询的效率
散列函数有一个共同性质，即函数值应按（）取其值域的每一个值。
A.最大概率
B.最小概率
C.同等概率
D.平均概率
已知有一个关键字序列：（19,14,23,1,68,20,84,27,55,11,10,79）散列存储在一个哈希表中，若散列函数为H（key）= key % 7，并采用链地址法来解决冲突，则在等概率情况下查找成功的平均查找长度为()
A.1.5
B.1.7
C.2.0
D.2.3
用哈希（散列）方法处理冲突（碰撞）时可能出现堆积（聚集）现象，下列选项中，会受堆积现象直接影响的是 ()
A.存储效率
B.数列函数
C.装填（装载）因子
D.平均查找长度
两句话中的不常见单词 – 力扣（LeetCode）

答案：

A：错误，哈希是一种用来进行高效查找的数据结构，查找的时间复杂度平均为O(1)
B：错误，哈希之所以高效，是引用使用了哈希函数将元素与其存储位置之间建立了一一对应的关系，因此必须使用哈希函数
C：错误，不一定，因为存在哈希冲突，一般基本都是O(1)
D：正确，采用哈希处理时，一般所需空间都会比元素个数多，否则产生冲突的概率就比较大，影响哈希的性能
哈希函数设计原则：1、哈希函数应该尽可能简单 2、哈希函数的值域必须在哈希表格的范围之内 3、哈希函数的值域应该尽可能均匀分布，即取每个位置应该是等概率的因此：选择C

在这里插入图片描述

冲突越多，查找时比较的次数就越多，对平均查找长度影响比较大。因此：选择D

class Solution {
public:
    vector<string> uncommonFromSentences(string s1, string s2) {
        // 将 s1 和 s2 拼接
        string s = s1 + " " + s2;

        vector<string> v;
        // 将每个单词插入到 v 中
        for(int i = 0; i < s.size(); ++i)
        {
            string tmp;
            while(i < s.size() && s[i] != ' ')
            {
                tmp += s[i];
                ++i;  
            }
            v.push_back(tmp);
        }

        // 统计每个单词出现的次数
        unordered_map<string, int> um;
        for(auto& e : v)
        {
            ++um[e];
        }

        // 清空 v，将um中单词出现次数为1的单词插入到v中
        v.clear();
        for(auto& [x, y] : um)
        {
            if(y == 1) v.push_back(x);
        }

        return v;
    }
};

12 条评论

乌萨奇也要立志学C++ 2025.10.01
作者在阐述每个知识点时，都力求详尽且清晰，使得读者可以轻松理解并掌握。此外，文章中还引用了一些具有代表性的代码片段，这些代码既展示了编程的魅力，也使得读者能够更好地理解相关概念和技巧，同时也希望可以来我博客指导我一番！
- 天地任我独行回复乌萨奇也要立志学C++ 2025.10.02
  感谢支持