【数据结构】位图和布隆过滤器

目录

位图概念

位图的实现

位图的扩展

布隆过滤器

哈希切分

---

给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在
这40亿个数中。
1. 遍历，时间复杂度O(N)
2. 排序(O(NlogN))，利用二分查找: logN
3. 位图解决
数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一
个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0
代表不存在。比如：

位图概念

所谓位图，就是用一个比特位来存放某种状态，适用于海量数据，数据无重复的场景。由于二进制 1 和 0 刚好对应存在与不存在，所以位图通常是用来判断某个数据存不存在的。

位图的实现

除了位段之外，没有一种变量可以表示一个比特位。但我们可以使用一个 int 数组，每个元素按照先后顺序，把每个元素的每个比特位也按照先后顺序表示一个数是否存在。

• 插入

1、把待插入的数除以 32，结果为这个数对应的比特位在第几个 int；

2、把待插入的数模 32，结果为这个数对应的比特位在这个 int 的第几个比特位。

3、使用位运算，要求不管这个数对应的比特位是 0 还是 1，都把它标记为 0 或 1。

// x映射的那个标记成1
void set(size_t x)
{size_t i = x / 32;size_t j = x % 32;_a[i] |= (1 << j);
}// x映射的那个标记成0
void reset(size_t x)
{size_t i = x / 32;size_t j = x % 32;_a[i] &= (~(1 << j));
}

• 判断值是否存在

bool test(size_t x)
{size_t i = x / 32;size_t j = x % 32;return _a[i] & (1 << j);
}

位图的扩展

1、可以用两个比特位表示某种状态：00 表示从来没出现过，01 表示出现 1 次，10 表示出现两次及以上。

2、也可以用两个位图的同一位共同表示某种状态：

• A 位图某位置为 0，B 位图对应位置也为 0，表示从来没出现过，
• A 位图某位置为 0，B 位图对应位置为 1，表示出现 1 次，
• A 位图某位置为 1，B 位图对应位置为 0，表示出现两次及以上。

布隆过滤器

布隆过滤器提出

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

1. 用哈希表存储用户记录，缺点：浪费空间
2. 用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理了。
3. 将哈希与位图结合，即布隆过滤器

布隆过滤器概念
布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概
率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存
在”，它是用多个哈希函数，将一个字符串映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。字符串映射到位图结构会不可避免的产生冲突，但使用多个哈希函数，将一个字符串映射到多个比特位，可以降低冲突的概率，但是空间的消耗增加了。如何权衡布隆过滤器的空间大小，使得冲突概率最小的情况下，消耗最小的空间，根据大佬的数学推导，这个关系是：m = 4.3 * n（m：布隆过滤器的空间大小，n：要插入的元素个数）

布隆过滤器的查找

布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。
比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但实该元素是不存在的。

布隆过滤器删除

布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素。
比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。

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

1. 无法确认元素是否真正在布隆过滤器中
2. 存在计数回绕

布隆过滤器优点

1. 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
2. 哈希函数相互之间没有关系，方便硬件并行运算
3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算

布隆过滤器缺陷

1. 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再建立一个白名单，存储可能会误判的数据)
2. 不能获取元素本身
3. 一般情况下不能从布隆过滤器中删除元素
4. 如果采用计数方式删除，可能会存在计数回绕问题

#pragma once
#include<bitset>
#include<string>struct BKDRHash
{size_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash = hash * 131 + ch;}//cout <<"BKDRHash:" << hash << endl;return hash;}
};struct APHash
{size_t operator()(const string& str){size_t hash = 0;for (size_t i = 0; i < str.size(); i++){size_t ch = str[i];if ((i & 1) == 0){hash ^= ((hash << 7) ^ ch ^ (hash >> 3));}else{hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));}}//cout << "APHash:" << hash << endl;return hash;}
};struct DJBHash
{size_t operator()(const string& str){size_t hash = 5381;for(auto ch : str){hash += (hash << 5) + ch;}//cout << "DJBHash:" << hash << endl;return hash;}
};template<size_t N, class K = string,class Hash1 = BKDRHash,class Hash2 = APHash,class Hash3 = DJBHash>
class BloomFilter
{
public:void Set(const K& key){size_t hash1 = Hash1()(key) % N; // Hash1() 匿名对象_bs.set(hash1);size_t hash2 = Hash2()(key) % N;_bs.set(hash2);size_t hash3 = Hash3()(key) % N;_bs.set(hash3);/* cout << hash1 << endl;cout << hash2 << endl;cout << hash3 << endl << endl;*/}bool Test(const K& key){size_t hash1 = Hash1()(key) % N;if (_bs.test(hash1) == false)return false;size_t hash2 = Hash2()(key) % N;if (_bs.test(hash2) == false)return false;size_t hash3 = Hash3()(key) % N;if (_bs.test(hash3) == false)return false;return true; // 可能存在误判}private:bitset<N> _bs;
};

哈希切分

1. 问题重述

• 有两个文件 A 和 B，每个文件有 100 亿行，每行是一个 query（可以理解为一个字符串）。

• 可用内存：1 GB。

• 目标：找出两个文件的交集（精确匹配的 query）。

• 要求：给出 精确算法（不能是近似算法，如 Bloom Filter 可能漏判）。

---

2. 数据量估计

假设每个 query 平均长度 50 字节（实际可能是 URL 或搜索词）。

• 单个文件大小 ≈ 1010×50 bytes=500 GB1010×50 bytes=500 GB

• 两个文件总共约 1000 GB（1 TB）的数据量。

内存只有 1 GB，显然不能全部加载进内存做哈希。

---

3. 基本思路：哈希切分（分治思想）

核心思想：
将大文件通过哈希函数分成许多个小文件，使得每个小文件可以装入内存处理，并且 相同的 query 一定会被分到相同编号的小文件。

步骤：

1. 选择哈希函数
   选一个均匀的哈希函数 h(query)→{0,1,…,k−1}h(query)→{0,1,…,k−1}，其中 kk 是分片数。

2. 确定分片数 kk
   我们需要每个小文件可以装入内存。
   假设我们切分成 kk 个小文件，那么每个文件大约 500GB/k500GB/k 大小。
   我们希望单个小文件可以全部读入内存做哈希表。
   可用内存 1 GB，但还要留一部分给哈希表结构（指针等开销），所以实际能装的原始数据应小于 1 GB。
   保守估计，每个小文件应当 ≤ 0.5 GB。

   k≥500 GB0.5 GB=1000k≥0.5 GB500 GB​=1000

   所以取 k=2000k=2000 或更多更安全（避免哈希不均匀导致某个文件过大）。

3. 切分过程

   • 对文件 A：逐行读入，计算 h(query)mod  kh(query)modk，将 query 写入文件 A_0.txt, A_1.txt, …, A_{k-1}.txt。

   • 对文件 B：同样操作，写入 B_0.txt, …, B_{k-1}.txt。

4. 关键性质
   如果某个 query 在 A 和 B 中都存在，那么它一定在相同编号的 A_i 和 B_i 文件中。
   因此，交集 = 所有 ii 的 A_i ∩ B_i 的并集。

5. 逐个对小文件求交集
   对于 i=0i=0 到 k−1k−1：

   • 读取 A_i.txt 到内存中的哈希集合。

   • 逐行读取 B_i.txt，检查是否在 A_i 的集合中，如果在，输出到交集结果文件。

4. 算法细节与优化

某个文件过大的问题

首先要弄清楚是由于有很多相同元素导致还是由于冲突太多导致

举一个例子：比如一个文件有5G：

• 4G都是相同query,1G冲突
• 大多数都是冲突

解决方案: 1、先把该文件的 query 读到一个 set

• 如果 set 的 insert 报错抛异常 (bad_alloc) , 那么就说明是大多数 query 都是冲突（set 的某个桶太大）。只需换个哈希函数，对该文件重新切分
• 如果能够全部读出来, insert 到 set 里面 , 那么说明该文件有大量相同的 query（set 不允许插入相同元素）