C++ 哈希+unordered_map+unordered_set+位图+布隆过滤器（深度剖析）

2024-03-19 04:00:07 分类：前端 热度：209 评论： 0

C++ 哈希+unordered_map+unordered_set+位图+布隆过滤器（深度剖析）

1. 前言

想象一下，你有一个巨大的图书馆，里面摆满了成千上万本书。如果你想要找到其中一本特定的书，你会怎么做？如果你按照书的编号来有序地排列它们，找到特定的书本可能会很容易。但是，如果书籍是随机地摆放，你可能需要逐本地查找，这个过程会非常耗时。

而哈希函数就像是给每本书分配一个独特的编号，然后将它们放置在合适的位置，使得我们能够快速地找到并访问它们。哈希函数能够将输入数据映射到一个固定大小的哈希表中，每个元素都有一个唯一的位置。当我们需要查找特定的元素时，只需使用哈希函数计算出它的位置，然后直接访问该位置的元素，无需遍历整个数据集。

这种基于哈希的快速查找技术在现代编程中非常常见。在本篇博客中，我们将深入剖析哈希相关的知识点。

本篇文章将着重讲解 unordered 系列关联式容器（unordered_map 和 unordered_set）、底层结构（哈希的概念、哈希函数、哈希冲突）、模拟实现（unordered_map 和 unordered_set 的模拟实现）以及哈希的应用（位图和布隆过滤器）。

2. unordered 系列关联式容器

在 C++98 中，STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2N log2​N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在 C++11 中，STL又提供了4个 unordered 系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对 unordered_map 和 unordered_set 进行介绍。

2.1 unordered_map

2.1.1 unordered_map 的概念

英文解释：

也就是说：

  1. unordered_map 是存储 <key, value> 键值对的关联式容器，其允许通过 key 快速的索引到与其对应的 value。

  2. 在 unordered_map 中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。

  3. 在内部，unordered_map 没有对 <key, value> 按照任何特定的顺序排序, 为了能在常数范围内找到 key 所对应的 value，unordered_map 将相同哈希值的键值对放在相同的桶中。

  4. unordered_map 容器通过 key 访问单个元素要比 map 快，但它通常在遍历元素子集的范围迭代方面效率较低。

  5. unordered_map 实现了直接访问操作符（operator[]），它允许使用 key 作为参数直接访问 value。

  6. 它的迭代器至少是单向迭代器。

2.1.2 unordered_map 的使用

  1. unordered_map 的模板参数列表

    说明：

    • key：键值对中 key 的类型。
    • T：键值对中 value 的类型。
    • Hash：哈希函数用于确定元素在内部数据结构中的位置。
    • Pred：键相等判断函数用于比较两个键是否相等。
    • Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器。

  2. unordered_map 的构造函数

    函数声明 功能介绍
    unordered_map 构造不同格式的 unordered_map 对象。

  3. unordered_map 的容量操作

    函数名称 函数声明 功能简介
    empty bool empty () const; 检测 unordered_map 中的元素是否为空，是返回 true，否则返回 false。
    size size_t size() const; 返回 unordered_map 中有效元素的个数。

  4. unordered_map 的元素访问操作

    函数名称 函数声明 功能简介
    operator[] mapped_type& operator[] (const key_type& k); 返回 k 对应的 value。
    at mapped_type& at (const key_type& k);
    const mapped_type& at (const key_type& k) const;     		返回 k 对应的 value。

    区分：

    在元素访问时，有一个与 operator[] 类似的操作 at 函数（该函数不常用），都是通过 key 找到与 key 对应的 value 然后返回其引用，不同的是：当 key 不存在时，operator[] 用默认 value 与 key 构造键值对然后插入，返回该默认 value；at 函数直接抛异常。

  5. unordered_map 的查找操作

    函数名称 函数声明 功能介绍
    find iterator find (const key_type& k);
    const_iterator find (const key_type& k) const;     		在 unordered_map 中查找 key 为 k 的元素，找到返回该元素位置的迭代器，否则返回 end。
    在 unordered_map 中查找 key 为 k 的元素，找到返回该元素位置的 const 迭代器，否则返回 cend。
    count size_t count (const key_type& k) const; 返回 unordered_map 中值为 k 的键值在 map 中的个数（这里只会返回0或1）。

  6. unordered_map 的修改操作

    函数名称 函数声明 功能介绍
    insert pair<iterator,bool> insert (const value_type& val); 在 unordered_map 中插入键值对 val。如果插入成功，返回 <val 位置的迭代器，true>；如果插入失败，说明 val 在 unordered_map 中已经存在，返回 <val 位置的迭代器，false>。
    erase iterator erase (const_iterator position);
    size_t erase (const key_type& k);     		删除 unordered_map 中 position 位置上的元素，并返回一个指向被删除元素之后位置的迭代器。
    删除 unordered_map 中键值为 k 的元素，返回删除的元素的个数（这里只会返回0或1）。
    swap void swap (unordered_map& ump); 与 ump 交换元素。
    clear void clear(); 将 map 的元素清空。

  7. unordered_map 的桶操作

    函数名称 函数声明 功能介绍
    bucket_count size_t bucket_count() const 返回哈希桶中桶的总个数。
    bucket_size size_t bucket_size(size_t n) const 返回 n 号桶中有效元素的总个数。
    bucket size_t bucket(const key_type& k) 返回元素 k 所在的桶号。

2.2 unordered_set

2.2.1 unordered_set 的概念

英文解释：

也就是说：

  1. unordered_set 是一种容器，它以无特定顺序存储唯一元素，并且允许根据 value 快速检索单个元素。

  2. 在 unordered_set 中，元素的 value 同时也是唯一标识它的 key。键是不可变的，因此，在容器中的元素一旦插入就不能修改，尽管可以插入和删除。

  3. 在内部，unordered_set 中的元素没有按照任何特定的顺序排序，而是根据它们的哈希值被组织到不同的桶中，以便能够通过值快速直接地访问单个元素（平均情况下具有常数时间复杂度）。

  4. 与集合容器相比，unordered_set 容器更快地通过 key 访问单个元素，尽管对于对子集进行范围迭代，它们通常不太高效。

  5. 容器中的迭代器至少是单向迭代器。

2.2.2 unordered_set 的使用

  1. unordered_set 的模板参数列表

    说明：

    • T：unordered_set 中存放元素的类型。

    • Hash：哈希函数用于确定元素在内部数据结构中的位置。

    • Pred：键相等判断函数用于比较两个键是否相等。

    • Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器。

  2. unordered_set 的构造函数

    函数声明 功能介绍
    unordered_set 构造不同格式的 unordered_set 对象。

  3. unordered_set 的容量操作

    函数名称 函数声明 功能介绍
    empty bool empty() const; 检测 unordered_set 是否为空，空返回 true，否则返回 false。
    size size_t size() const; 返回 unordered_set 中有效元素的个数。

  4. unordered_set 的查找操作

    函数名称 函数声明 功能介绍
    find iterator find (const value_type& val) const; 在 unordered_set 中查找值为 val 的元素，如果找到则返回该元素位置的迭代器，未找到则返回 end 迭代器。
    count size_t count (const value_type& val) const; 返回 unordered_set 中值为 val 的元素的个数（这里只会返回0或1）。

  5. unordered_set 的修改操作

    函数名称 函数声明 功能介绍
    insert pair<iterator,bool> insert (const value_type& val); 在 unordered_set 中插入元素 val。如果插入成功，返回 <val 位置的迭代器，true>；如果插入失败，说明 val 在 unordered_set 中已经存在，返回 <val 位置的迭代器，false>。
    erase iterator erase (const_iterator position);
    size_t erase (const value_type& val);     		删除 unordered_set 中 position 位置上的元素，并返回一个指向被删除元素之后位置的迭代器。
    删除 unordered_set 中值为 val 的元素，返回删除的元素的个数（这里只会返回0或1）。
    swap void swap (unordered_set& ust); 与 ust 交换元素。
    clear void clear(); 将 unordered_set 的元素清空。

  6. unordered_set 的桶操作

    函数名称 函数声明 功能介绍
    bucket_count size_t bucket_count() const 返回哈希桶中桶的总个数。
    bucket_size size_t bucket_size(size_t n) const 返回 n 号桶中有效元素的总个数。
    bucket size_t bucket(const key_type& k) 返回元素 k 所在的桶号。

3. 底层结构

3.1 哈希的概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

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

当向该结构中：

  • 插入元素

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

  • 搜索元素

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

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

例如：

数据集合：{ 1,7,6,4,5,9 };

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

图解：

注：用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

3.2 哈希冲突

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

把具有不同关键码而具有相同哈希地址的数据元素称为同义词。

发生哈希冲突该如何处理呢？

3.3 哈希函数

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

哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有 m 个地址时，其值域必须在 0 到 m-1 之间。
  • 哈希函数计算出来的地址能均匀分布在整个空间中。
  • 哈希函数应该比较简单。

常见哈希函数

  1. 直接定址法（常用）

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

优点：简单、均匀。

缺点：需要事先知道关键字的分布情况。

使用场景：适合查找比较小且连续的情况。

  1. 除留余数法（常用）

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

  1. 平方取中法（了解）

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

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

  1. 折叠法（了解）

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

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

  1. 随机数法（了解）

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

随机数法通常应用于关键字长度不等时。

  1. 数学分析法（了解）

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

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

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

拓展：字符串Hash函数链接。

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

3.4 哈希冲突的解决

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

3.4.1 闭散列

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

  1. 线性探测

    比如3.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr 为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

    • 插入

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

    • 删除

      采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。

      比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

      像这样：

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

    思考：哈希表什么情况下进行扩容？如何扩容？

    线性探测的实现

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

// 字符串哈希函数特化：HashFunc<string>
template<>
struct HashFunc<std::string>
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

namespace open_address
{
	enum Status
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		Status _s;          //状态
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
		{
			_tables.resize(10);
		}

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

			// 负载因子0.7就扩容
			if (_n * 10 / _tables.size() == 7)
			{
				size_t newSize = _tables.size() * 2;
				HashTable<K, V, Hash> newHT;
				newHT._tables.resize(newSize);
				// 遍历旧表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._s == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}

				_tables.swap(newHT._tables);
			}

			Hash hf;
			// 线性探测
			size_t hashi = hf(kv.first) % _tables.size();
			while (_tables[hashi]._s == EXIST)
			{
				hashi++;

				hashi %= _tables.size();
			}

			_tables[hashi]._kv = kv;
			_tables[hashi]._s = EXIST;
			++_n;

			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			Hash hf;

			size_t hashi = hf(key) % _tables.size();
			while (_tables[hashi]._s != EMPTY)
			{
				if (_tables[hashi]._s == EXIST
					&& _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}

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

			return nullptr;
		}

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

        // 打印观察分布
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._s == EXIST)
				{
					cout << "[" << i << "]->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;
				}
				else if (_tables[i]._s == EMPTY)
				{
					printf("[%zd]->\n", i);
				}
				else
				{
					printf("[%zd]->D\n", i);
				}
			}

			cout << endl;
		}

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0; // 存储的关键字的个数
	};
}

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

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

  2. 二次探测

    线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： 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 是表的大小。

    对于3.1中如果要插入44，产生冲突，使用解决后的情况为：

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

    因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

3.4.2 开散列

  1. 开散列概念

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

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

  1. 开散列增容

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

  1. 开散列实现
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 字符串哈希函数特化：HashFunc<string>
template<>
struct HashFunc<std::string>
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

namespace hash_bucket
{
	template<class K, class V>
	struct HashNode
	{
		HashNode* _next;
		pair<K, V> _kv;

		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()
		{
			_tables.resize(10);
		}

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

		size_t Size() const
		{
			return _n;
		}

		bool Empty() const
		{
			return _n == 0;
		}

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

			Hash hf;

			// 负载因子最大到1
			if (_n == _tables.size())
			{
				vector<Node*> newTables;
				newTables.resize(_tables.size() * 2, nullptr);
				// 遍历旧表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;

						// 挪动到映射的新表
						size_t hashi = hf(cur->_kv.first) % newTables.size();
						cur->_next = newTables[i];
						newTables[i] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = hf(kv.first) % _tables.size();
			Node* newnode = new Node(kv);

			// 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;

			return true;
		}

		bool Erase(const K& key)
		{
			Hash hf;
			size_t hashi = hf(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;
					}
					delete cur;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

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

				cur = cur->_next;
			}

			return nullptr;
		}

		size_t Count(const K& key)
		{
			Hash hf;
			KeyOfT kot;

			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return 1;
				}

				cur = cur->_next;
			}

			return 0;
		}

		// 桶的总个数
		size_t BucketCount()
		{
			size_t bucketCount = 0;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					++bucketCount;
				}
			}
			return bucketCount;
		}

		// key所在桶的大小
		size_t BucketSize(const K& key)
		{
			Hash hf;
			size_t bucketSize = 0;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				++bucketSize;
				cur = cur->_next;
			}
			return bucketSize;
		}

        // 打印信息
		void Some()
		{
			size_t bucketSize = 0;
			size_t maxBucketLen = 0;
			size_t sum = 0;
			double averageBucketLen = 0;

			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					++bucketSize;
				}

				size_t bucketLen = 0;
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}

				sum += bucketLen;

				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}

			averageBucketLen = (double)sum / (double)bucketSize;

			printf("all bucketSize:%d\n", _tables.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}

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

开散列与闭散列比较

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

4. 模拟实现

4.1 哈希表的改造

  1. 模板参数列表的改造

    // K：关键码类型
// T：不同容器T的类型不同，如果是unordered_map，T代表一个键值对，如果是unordered_set,T为K。
// KeyOfT：因为T的类型不同，通过value取key的方式就不同，详细见unordered_map/set的实现。
// Hash：哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整型数字才能取模。
template<class T>
struct HashNode
{
	HashNode<T>* _next;
	T _data;

	HashNode(const T& data)
		:_data(data)
		, _next(nullptr)
	{}
};
template<class K, class T, class KeyOfT, class Hash>
class HashTable;

  2. 增加迭代器操作

    template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
struct __HTIterator
{
	typedef HashNode<T> Node;
	typedef __HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;
	Node* _node;
	const HashTable<K, T, KeyOfT, Hash>* _pht;
	size_t _hashi;

	__HTIterator(Node* node, HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
		:_node(node)
		, _pht(pht)
		, _hashi(hashi)
	{}

	__HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
		:_node(node)
		, _pht(pht)
		, _hashi(hashi)
	{}

	Self& operator++()
	{
		if (_node->_next)
		{
			// 当前桶还有节点，走到下一个节点
			_node = _node->_next;
		}
		else
		{
			// 当前桶已经走完了，找下一个桶开始
			++_hashi;
			while (_hashi < _pht->_tables.size())
			{
				if (_pht->_tables[_hashi])
				{
					_node = _pht->_tables[_hashi];
					break;
				}

				++_hashi;
			}

			if (_hashi == _pht->_tables.size())
			{
				_node = nullptr;
			}
		}

		return *this;
	}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
};

  3. 改造后代码实现

    template<class K, class T, class KeyOfT, class Hash>
class HashTable
{
	typedef HashNode<T> Node;

	template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
	friend struct __HTIterator;

public:
	typedef __HTIterator<K, T, T&, T*, KeyOfT, Hash> iterator;
	typedef __HTIterator<K, T, const T&, const T*, KeyOfT, Hash> const_iterator;

	iterator begin()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			if (_tables[i])
			{
				return iterator(_tables[i], this, i);
			}
		}

		return end();
	}

	iterator end()
	{
		return iterator(nullptr, this, -1);
	}

	const_iterator begin() const
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			if (_tables[i])
			{
				return const_iterator(_tables[i], this, i);
			}
		}

		return end();
	}

	const_iterator end() const
	{
		return const_iterator(nullptr, this, -1);
	}

	HashTable()
	{
		_tables.resize(10);
	}

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

	size_t Size() const
	{
		return _n;
	}

	bool Empty() const
	{
		return _n == 0;
	}

	pair<iterator, bool> Insert(const T& data)
	{
		Hash hf;
		KeyOfT kot;

		iterator it = Find(kot(data));
		if (it != end())
			return make_pair(it, false);

		// 负载因子最大到1
		if (_n == _tables.size())
		{
			vector<Node*> newTables;
			newTables.resize(_tables.size() * 2, nullptr);
			// 遍历旧表
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;

					// 挪动到映射的新表
					size_t hashi = hf(kot(cur->_data)) % newTables.size();
					cur->_next = newTables[i];
					newTables[hashi] = cur;

					cur = next;
				}

				_tables[i] = nullptr;
			}

			_tables.swap(newTables);
		}

		size_t hashi = hf(kot(data)) % _tables.size();
		Node* newnode = new Node(data);

		// 头插
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;
		++_n;

		return make_pair(iterator(newnode, this, hashi), true);
	}

	bool Erase(const K& key)
	{
		Hash hf;
		KeyOfT kot;

		size_t hashi = hf(key) % _tables.size();
		Node* prev = nullptr;
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == key)
			{
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}
				delete cur;

				return true;
			}

			prev = cur;
			cur = cur->_next;
		}

		return false;
	}

	iterator Find(const K& key)
	{
		Hash hf;
		KeyOfT kot;

		size_t hashi = hf(key) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == key)
			{
				return iterator(cur, this, hashi);
			}

			cur = cur->_next;
		}

		return end();
	}


	size_t Count(const K& key)
	{
		Hash hf;
		KeyOfT kot;

		size_t hashi = hf(key) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == key)
			{
				return 1;
			}

			cur = cur->_next;
		}

		return 0;
	}

	// 桶的总个数
	size_t BucketCount()
	{
		size_t bucketCount = 0;
		for (size_t i = 0; i < _tables.size(); i++)
		{
			if (_tables[i])
			{
				++bucketCount;
			}
		}
		return bucketCount;
	}

	// key所在桶的大小
	size_t BucketSize(const K& key)
	{
		Hash hf;
		size_t bucketSize = 0;
		size_t hashi = hf(key) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur)
		{
			++bucketSize;
			cur = cur->_next;
		}
		return bucketSize;
	}

	// 打印信息
	void Some()
	{
		size_t bucketSize = 0;
		size_t maxBucketLen = 0;
		size_t sum = 0;
		double averageBucketLen = 0;

		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			if (cur)
			{
				++bucketSize;
			}

			size_t bucketLen = 0;
			while (cur)
			{
				++bucketLen;
				cur = cur->_next;
			}

			sum += bucketLen;

			if (bucketLen > maxBucketLen)
			{
				maxBucketLen = bucketLen;
			}
		}

		averageBucketLen = (double)sum / (double)bucketSize;

		printf("all bucketSize:%zd\n", _tables.size());
		printf("bucketSize:%zd\n", bucketSize);
		printf("maxBucketLen:%zd\n", maxBucketLen);
		printf("averageBucketLen:%lf\n\n", averageBucketLen);
	}

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

4.2 unordered_map 的模拟实现

unordered_map 的底层结构就是哈希表，因此在 unordered_map 中直接封装一个哈希表，然后将其接口包装下即可。

代码实现如下：

#pragma once
#include"HashTable.h"

namespace my_unordered_map
{
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::iterator iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		size_t size() const
		{
			return _ht.Size();
		}

		bool empty() const
		{
			return _ht.Empty();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
			return ret.first->second;
		}

		const V& operator[](const K& key) const
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
			return ret.first->second;
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		size_t count(const K& key)
		{
			return _ht.Count(key);
		}

		size_t bucket_count()
		{
			return _ht.BucketCount();
		}
		
		size_t bucket_size(const K& key)
		{
			return _ht.BucketSize(key);
		}

	private:
		hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
	};
}

4.3 unordered_set 的模拟实现

unordered_set 的底层结构就是哈希表，因此在 unordered_set 中直接封装一个哈希表，然后将其接口包装下即可。

代码实现如下：

#pragma once
#include"HashTable.h"

namespace my_unordered_set
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator iterator;
		typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator const_iterator;

		iterator begin() const
		{
			return _ht.begin();
		}

		iterator end() const
		{
			return _ht.end();
		}

		size_t size() const
		{
			return _ht.Size();
		}

		bool empty() const
		{
			return _ht.Empty();
		}

		pair<const_iterator, bool> insert(const K& key)
		{
			auto ret = _ht.Insert(key);
			return pair<const_iterator, bool>(const_iterator(ret.first._node, ret.first._pht, ret.first._hashi), ret.second);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}

		iterator find(const K& key)
		{
			auto ret = _ht.Find(key);
			return const_iterator(ret._node, ret._pht, ret._hashi);
		}

		size_t count(const K& key)
		{
			return _ht.Count(key);
		}

		size_t bucket_count()
		{
			return _ht.BucketCount();
		}

		size_t bucket_size(const K& key)
		{
			return _ht.BucketSize(key);
		}
		
	private:
		hash_bucket::HashTable<K, K, SetKeyOfT, Hash> _ht;
	};
}

5. 哈希的应用

5.1 位图

5.1.1 位图的概念

所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。

来看一个问题：

给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中？

  1. 遍历 O ( N ) O(N) O(N)

  2. 排序 O ( N l o g 2 N ) O(Nlog_2N) O(Nlog2​N) + 二分查找 O ( l o g 2 N ) O(log_2N) O(log2​N)

  3. 位图解决

数据是否在给定的整型数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息。如果二进制比特位为1，则代表存在；二进制比特位为0，则代表不存在。

比如：

5.1.2 位图的实现

namespace my_bitset
{
	// N是需要多少比特位
	template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			_bits.resize((N >> 5) + 1, 0);
		}

		void set(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_bits[i] |= (1 << j);
		}

		void reset(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_bits[i] &= ~(1 << j);
		}

		bool test(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;

			return _bits[i] & (1 << j);
		}
	private:
		vector<int> _bits;
	};
}

5.1.3 位图的应用

  1. 快速查找某个数据是否在一个集合中。

  2. 排序 + 去重。

  3. 求两个集合的交集、并集等。

  4. 操作系统中磁盘块标记。

以下面三个题为例：

  1. 给定100亿个整数，设计算法找到只出现一次的整数？

  2. 给两个文件，分别有100亿个整数，我们只有 1G 内存，如何找到两个文件交集？

  3. 位图应用变形：1个文件有100亿个 int，1G 内存，设计算法找到出现次数不超过2次的所有整数。

思路解答：

  1. 创建两个位图，遍历给定的100亿个整数。对于每个整数，如果出现一次，则将两个位图中对应位置分别置成01；如果出现零次、二次及以上，则将两个位图中对应位置分别置成00、10或11，最后，再次遍历位图，找到位图位置对应的值为01的整数。
  2. 将两个文件中的整数分别映射到两个位图中。然后，遍历其中一个位图，对于每个整数，查询另一个位图，如果对应位置的值为1，则表示该整数存在于两个文件中，即为所求交集。
  3. 创建两个位图，初始化所有位为0。然后，遍历给定的100亿个整数，对于每个整数，将其对应的位图位置的值加1（这里加1指的是调整两个位图对应位置组合成的数加1）。最后，再次遍历位图，找到位图位置对应的值不超过2的整数。

5.2 布隆过滤器

5.2.1 布隆过滤器的提出

我们在使用新闻客户端看新闻时，它会给我们不停地推荐新的内容，它每次推荐时要去重，去掉那些已经看过的内容。问题来了，新闻客户端推荐系统如何实现推送去重的？ 用服务器记录了用户看过的所有历史记录，当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选，过滤掉那些已经存在的记录。 如何快速查找呢？

  1. 用哈希表存储用户记录，缺点：浪费空间。

  2. 用位图存储用户记录，缺点：位图一般只能处理整型，如果内容编号是字符串，就无法处理了。

  3. 将哈希与位图结合，即布隆过滤器。

5.2.2 布隆过滤器的概念

布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你某样东西一定不存在或者可能存在，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。

5.2.3 布隆过滤器的实现

  1. 布隆过滤器的插入

    往布隆过滤器增加元素，添加的 key 需要根据 k 个无偏 hash 函数计算得到多个 hash 值，然后对数组长度进行取模得到数组下标的位置，然后将对应数组下标的位置的值置为1。

  2. 布隆过滤器的查找

    布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：

    分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

    注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。

    比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但实该元素是不存在的。

  3. 布隆过滤器的删除

    布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素。

    比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。

    一种支持删除的方法：将布隆过滤器中的每个比特位扩展成一个小的计数器。插入元素时给 k 个计数器（k 个哈希函数计算出的哈希地址）加一；删除元素时，给 k 个计数器减一。这样通过多占用几倍存储空间的代价来增加删除操作。

  4. 具体实现代码

    #pragma once
#include"bitset.h"

struct BKDRHash
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

struct APHash
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (size_t i = 0; i < key.size(); i++)
		{
			char ch = key[i];
			if ((i & 1) == 0)
			{
				hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
			}
			else
			{
				hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
			}
		}
		return hash;
	}
};

struct DJBHash
{
	size_t operator()(const string& key)
	{
		size_t hash = 5381;
		for (auto ch : key)
		{
			hash += (hash << 5) + ch;
		}
		return hash;
	}
};

template<size_t N,
	class K = string,
	class HashFunc1 = BKDRHash,
	class HashFunc2 = APHash,
	class HashFunc3 = DJBHash>
class BloomFilter
{
public:
	void Set(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % N;
		size_t hash2 = HashFunc2()(key) % N;
		size_t hash3 = HashFunc3()(key) % N;

		_bs.set(hash1);
		_bs.set(hash2);
		_bs.set(hash3);
	}

	bool Test(const K& key)
	{
		// 判断不存在是准确的
		size_t hash1 = HashFunc1()(key) % N;
		if (_bs.test(hash1) == false)
			return false;

		size_t hash2 = HashFunc2()(key) % N;
		if (_bs.test(hash2) == false)
			return false;

		size_t hash3 = HashFunc3()(key) % N;
		if (_bs.test(hash3) == false)
			return false;

		// 存在误判的
		return true;
	}

private:
	my_bitset::bitset<N> _bs;
};

5.2.4 布隆过滤器的优点

  1. 增加和查询元素的时间复杂度为: O ( K ) O(K) O(K), （ K K K为哈希函数的个数，一般比较小），与数据量大小无关。

  2. 哈希函数相互之间没有关系，方便硬件并行运算。

  3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势。

  4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势。

  5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能。

  6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算。

5.2.5 布隆过滤器的缺陷

  1. 有误判率，即存在假阳性（False Position），即不能准确判断元素是否在集合中。（补救方法：再建立一个白名单，存储可能会误判的数据）

  2. 不能获取元素本身。

  3. 一般情况下不能从布隆过滤器中删除元素。

  4. 如果采用计数方式删除，可能会存在计数回绕问题。

转载请说明出处内容投诉
CSS教程_站长资源网 » C++ 哈希+unordered_map+unordered_set+位图+布隆过滤器（深度剖析）
努力！奋斗已认证

努力！奋斗已认证

分享到：

相关推荐

发表评论

欢迎 访客 发表评论

一个令你着迷的主题！

查看演示 官网购买