【C++】位图 + 布隆过滤器

[1. 位图](#1. 位图)
- [1.1. 概念](#1.1. 概念)
- [1.2. 实现](#1.2. 实现)
- [1.3. 应用](#1.3. 应用)
[2. 布隆过滤器](#2. 布隆过滤器)
- [2.1. 背景](#2.1. 背景)
- [2.2. 概念](#2.2. 概念)
- [2.3. 实现](#2.3. 实现)
- [2.4. 优点](#2.4. 优点)
- [2.5. 缺点](#2.5. 缺点)
[3. 海量数据面试题](#3. 海量数据面试题)
- [3.1. 哈希切割](#3.1. 哈希切割)
- [3.2. 位图应用](#3.2. 位图应用)
- [3.3. 布隆过滤器](#3.3. 布隆过滤器)
- [3.4. 总结](#3.4. 总结)

1. 位图

1.1. 概念

位图是一种用于高效地存储和操作集合的数据结构。它的基本思想是使用一个二进制位(0或1)来表示一个元素是否存在于集合中，位图中的每一位对应着集合中的某个元素，可以通过直接访问某个位来判断某个元素在不在集合中。若某个元素在集合中，则对应位为1，否则，对应位为0。
位图是使用"哈希(映射)"这种思想实现的，计算集合中的元素在位图中的存储位置，采用哈希的直接定址法。适用于海量数据，数据无重复的场景。一般常用于判断某个数据是否存在。
位图开辟空间时，空间大小为数据类型范围的最大值，不是数据的个数，使用非类型模板参数N。eg : 整数，包括有、无符号整数，最大值为2^32-1，非类型模板参数N=UINT_MAX、0XFFFFFFFF(16进制)、-1(自动转换为size_t)，共需要500MB内存空间。
位图优缺点：高效存储，节省空间；快速查询，时间复杂度为O(1)；只适用于整型数据(%）；快速集合运算等。

1.2. 实现

cpp 复制代码

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>

using namespace std;

namespace zzx{ //位图，采用"哈希"思想来实现的
	template<size_t N> //非类型模板参数，位图大小开的是数据类型的范围，不是数据的个数
	class bitset{
	public:
		bitset()  //构造函数，提前开辟好空间，防止[]越界访问
		{
			_bits.resize(N/32 + 1, 0); //多开辟一个int,eg:66,并将位图的每一位初始化为0
		}

		void set(size_t x) //将x映射的位设置为1
		{
			int i = x / 32; //x存储在数组的第i个整型数据
			int j = x % 32;   //x存储在数组的这个整数的第j位
			_bits[i] |= (1 << j);  //其他位不变，第j位变为1
		}

		void reset(size_t x) //将x映射的位设置为0
		{
			int i = x / 32;  
			int j = x % 32;
			_bits[i] &= ~(1 << j);  //其他位不变，第j位变为0
		}

		bool test(size_t x)  //测试x映射位的值是否为1(状态)
		{
			int i = x / 32;
			int j = x % 32;
			return _bits[i] & (1 << j); //整形转bool，0为假，非0为真
		}

	private:
		vector<int> _bits; //底层为数组
	};
}

1.3. 应用

快速查询某一个数据是否在一个集合中。结果是在或不在，只有两种状态，可以用一个二进制比特位来代表数据是否存在的信息。位图中的每一位对应集合中的某个元素，通过直接定址法直接访问某个元素在位图中的存储位，对应位为1表示在，对应位为0表示不在。
排序 + 去重。集合中的元素在位图中的存储位置，采用哈希的直接定址法，从头到尾打印位图，就可以得到一个有序的集合。位图空间大小为数据类型的范围，大小固定的，重复的元素会映射到同一位，达到去重的目的。
求两个集合的交集或者并集。将两个集合set到两个位图中，test同时为1的就为交集，否则，为并集。
操作系统中磁盘块标记。

2. 布隆过滤器

2.1. 背景

位图只适用于整形数据，对于字符串，位图就无法处理了。

需要先通过哈希函数将字符串转化为整形，在进行映射存储位置，但会出现哈希冲突，从而导致"误判"(不在：对应位为0, 准确的、在：对应位为1, 可能会有"误判",因为映射位置的冲突，会将不在误判成在)。

为了降低哈希冲突的概率，就有人提出了通过多个不同的哈希函数对key进行不同位置的映射，只要有一个映射位置的值不同，就不在，误判率降低，但仍会有哈希冲突，无法百分百避免。

2.2. 概念

布隆过滤器是一种数据结构，它实际上是很长的二进制向量和一系列随机映射函数。由一个很长的bit数组和一系列哈希函数组成。
它的特点是高效的插入、查询，可以用来告诉你"某样东西一定不存在或者可能存在"，相比于传统的list、set、map等数据结构，它更高效，占用的空间内存更少，缺点是返回的结果具有概率性，不是确定的。它是用多个哈希函数，将一个数据映射到位图结构中。此方式不仅可以提升查询效率，也可以节省内存空间。

2.3. 实现

cpp 复制代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

#include"bitset.h"

struct HashFuncBKDR {
	//BKDR
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (auto& ch : s)
		{
			hash *= 131;
			hash += ch;
		}
		return hash;
	}
};

struct HashFuncAP
{
	// AP
	size_t operator()(const string& s)
	{
		size_t hash = 0;
		for (size_t i = 0; i < s.size(); i++)
		{
			if ((i & 1) == 0) // 偶数位字符
			{
				hash ^= ((hash << 7) ^ (s[i]) ^ (hash >> 3));
			}
			else              // 奇数位字符
			{
				hash ^= (~((hash << 11) ^ (s[i]) ^ (hash >> 5)));
			}
		}

		return hash;
	}
};

struct HashFuncDJB
{
	// DJB
	size_t operator()(const string& s)
	{
		size_t hash = 5381;
		for (auto ch : s)
		{
			hash = hash * 33 ^ ch;
		}

		return hash;
	}
};


template<size_t N, class K = string, class Hash1 = HashFuncBKDR, class Hash2 = HashFuncAP, class Hash3 = HashFuncDJB>
class BloomFilter {   //布隆过滤器
public:
	void set(const K& key)  //用多个哈希函数，将一个数据映射的位设置为1
	{
		int hash1 = Hash1()(key) % M; 
		int hash2 = Hash2()(key) % M; 
		int hash3 = Hash3()(key) % M;
		_bits.set(hash1);
		_bits.set(hash2);
		_bits.set(hash3);
	}

	bool test(const K& key)   //检验Key是否存在集合中
	{ //只要有一个映射位对应的值不同，就不存在，若全部相同，但仍有冲突的可能，导致"误判",无法规避
		int hash1 = Hash1()(key) % M;  
		int hash2 = Hash2()(key) % M;
		int hash3 = Hash3()(key) % M;

		if (_bits.test(hash1) == false) return false;
		if (_bits.test(hash2) == false) return false;
		if (_bits.test(hash3) == false) return false;
		return true;
	}

private:
	static const size_t M = 5 * N;  //N为插入的元素个数，M为布隆过滤器的长度
	zzx::bitset<M> _bits;  
};

2.4. 优点

增加、查询元素的时间复杂度位O(K)(K为哈希函数的个数，一般较小），与数据量的大小无关。
布隆过滤器不需要存储元素本身，对于保密要求比较严格的场合具有较大的优势。
各个哈希函数之间无联系，方便硬件并行运算。
数据量很大的时候，布隆过滤器可以表示全集，其他数据结构不能，如：平衡树，需要存储集合中的每个元素，布隆不需要，节省空间。
对于使用相同哈希函数的布隆过滤器，可以进行交集、并集、差集运算。

2.5. 缺点

有误判率，存在"假阳性"。因为哈希冲突，会把不在的误判成在。
不能获取元素本身。
不能从布隆过滤器中删除元素。
采用引用计数方式删除，会造成计数回绕、空间浪费等问题。

3. 海量数据面试题

3.1. 哈希切割

3.2. 位图应用

cpp 复制代码

//只出现一次的整数
template<size_t N>  
class two_bitset1 {
public:
	void set(size_t x) //插入
	{
		//0次(00)->1次(01)->2次及以上(10)
		if (_bs1.test(x) == 0 && _bs2.test(x) == 0)   _bs2.set(x);
		else
		{
			_bs1.set(x);
			_bs2.reset(x);
		}
	}

	bool test(size_t x) //找出只出现一次的元素
	{
		if (_bs1.test(x) == 0 && _bs2.test(x) == 1)  return true;
		else  return false;
	}

private:
    bitset<N> _bs1; //两个位图
	bitset<N> _bs2;
};

two_bitset1<UINT_MAX> tbs;
int a[] = { 1, 3, 8, 4, 1, 6, 3, 7, 4, 10, 2 };
for (auto& e : a)
{
	tbs.set(e);
}
for (auto& e : a)
{
	if (tbs.test(e))
		cout << e << endl;
}

cpp 复制代码

//求交集(需去重)
	bitset<20> bs1;
	bitset<20> bs2;
	int a1[] = { 10, 4, 8, 4, 2, 1, 5, 2 };
	int a2[] = { 10, 10, 4, 2, 2, 3 }; 
	for (auto& e : a1)
	{
		bs1.set(e);
	}
	for (auto& e : a2)
	{
		bs2.set(e); 
	}
	for (int i = 0; i < 20; i++) //去重了
	{
		if (bs1.test(i) && bs2.test(i))
			cout << i << endl;
	}
	cout << endl;
	for (auto& e : a2)  //未去重
	{
		if (bs1.test(e) && bs2.test(e))
			cout << e << endl;
	}

cpp 复制代码

//出现次数不超过2次的整数
template<size_t N>
class two_bitset2 {
public:
	void set(size_t x) //插入
	{
		//0次(00)->1次(01)->2次及以上(10)
		if (_bs1.test(x) == 0 && _bs2.test(x) == 0)   _bs2.set(x);
		else if(_bs1.test(x) == 0 && _bs2.test(x) == 1)  //注意，此处不能为if，因为上面if走完，会继续往下走
		{
			_bs1.set(x);
			_bs2.reset(x);
		}
		else
		{
			_bs1.set(x);
			_bs2.set(x);
		}
	}

	bool test(size_t x) //找出只出现一次的元素
	{
		if (_bs1.test(x) == 0 && _bs2.test(x) == 0)  return true;
		else  if (_bs1.test(x) == 0 && _bs2.test(x) == 1)  return true;
		else if (_bs1.test(x) == 1 && _bs2.test(x) == 0)  return true;
		return false;
	}

private:
	bitset<N> _bs1; //两个位图
	bitset<N> _bs2;
};

3.3. 布隆过滤器

3.4. 总结

海量数据的特征：数据量太大，内存存不下。
优先考虑具有特点的数据结构能否解决 -》位图、布隆过滤器、堆等。
其次进行"大事化小"，哈希切分，但不能平均切分，切小以后，放到内存中处理。

【C++】位图 + 布隆过滤器

目录

1. 位图

1.1. 概念

1.2. 实现

1.3. 应用

2. 布隆过滤器

2.1. 背景

2.2. 概念

2.3. 实现

2.4. 优点

2.5. 缺点

3. 海量数据面试题

3.1. 哈希切割

3.2. 位图应用

3.3. 布隆过滤器

3.4. 总结