搞懂位图和布隆过滤器

于 2023-04-23 19:06:03 发布
阅读量398 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58004346/article/details/130291826
版权

文章目录

位图

腾讯面试题

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

解决方法：

1.遍历，时间复杂度O(N)。
2.外排序(O(NlogN))，利用二分查找磁盘: logN，访问磁盘次数很多，效率很低。liunx排序指令
3.位图解决。- - 针对整形的 直接定址法。

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

在这里插入图片描述

位图概念

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

位图实现

  • 不需要考虑大小端。
  • 非类型模板参数 N 表示N个元素
	template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			_bits.resize(N/8+1, 0);// 开辟空间以字节为单位
		}
		// 设置对应位 为 1
		void set(size_t x)
		{
			size_t i = x / 8;
			size_t j = x % 8;

			_bits[i] |= (1 << j);
		}
		// 设置对应位位 0
		void reset(size_t x)
		{
			size_t i = x / 8;
			size_t j = x % 8;

			_bits[i] &= ~(1 << j);
		}
		// 测试 x 对应位是否为 1
		bool test(size_t x)
		{
			size_t i = x / 8;
			size_t j = x % 8;


			return _bits[i] & (1 << j);
		}

	private:
		vector<char> _bits;
	};

	void test_bit_set1()
	{
		bitset<100> bs1;
		bs1.set(8);
		bs1.set(9);
		bs1.set(20);

		cout << bs1.test(8) << endl;
		cout << bs1.test(9) << endl;
		cout << bs1.test(20) << endl;

		bs1.reset(8);
		bs1.reset(9);
		bs1.reset(20);

		cout << bs1.test(8) << endl;
		cout << bs1.test(9) << endl;
		cout << bs1.test(20) << endl;
	}

// 开辟。
	void test_bit_set2()
	{
	// 可以记录所有int整数状态
		bitset<-1> bs1;// 开辟512MB
		//bitset<0xffffffff> bs2;
	}

位图的应用

  1. 快速查找某个数据是否在一个集合中。
  2. 给正整数排序 + 去重 - - 时间 O(N) ,N:正整数的最大值,N越大位图越大 ，由于语言数据类型的限制，所以 N最大是 MAX_UNSIGNED_LONG_LONG 。当然也可以进行大数运算，大数运算有很多种，模拟法，位运算法，
  3. （了解）虽然c语言只支持int,long类型来存放数据, 实际计算机是使用位运算计算的,底层就是存放二进制数01序列,语言层限制了数据的范围,如果我们要进行大数运算,可以使用位运算进行模拟,例如,0xFFFFFFFFFFFFFFFF1数据已经突破了 unsigned long long 类型了,我们可以转换位 位图进行存储,让后使用位运算 计算. 转换过程比较复杂所以了解性学习
  4. 求两个集合的交集、并集等
  5. 操作系统中磁盘块标记
  6. 速度快，空间小。
  7. 局限性，只能映射处理整形。如果元素要进行哈希计算，那么映射的位置存在冲突，而位图不能处理冲突的。所以位图采用的是直接定址法，不会产生冲突。

位图的应用题

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

解题步骤：

  • 100亿个整数会出现重复，整数的范围在 0~4294967295,因此实际只需要开辟 4294967295个比特位就行。即 0xFFFFFFFF。
  • 两张位图加起来为 85亿多比特位。
  • 使用两个位图表表示 0，1和1次以上的状态。
	template<size_t N>
	class twobitset
	{
	public:
		void set(size_t x)
		{
			bool inset1 = _bs1.test(x);
			bool inset2 = _bs2.test(x);

			// 00
			if (inset1 == false && inset2 == false)
			{
				// -> 01
				_bs2.set(x);
			}
			else if (inset1 == false && inset2 == true)
			{
				// ->10
				_bs1.set(x);
				_bs2.reset(x);
			}
			else if (inset1 == true && inset2 == false)
			{
				// ->11
				_bs1.set(x);
				_bs2.set(x);
			}
		}
	
		// 遍历所有正整数，打印条件满足只出现一次的整数
		void print_once_num()
		{
			for (size_t i = 0; i < N; ++i)
			{
				if (_bs1.test(i) == false && _bs2.test(i) == true)
				{
					cout << i << endl;
				}
			}
		}

	private:
		bitset<N> _bs1;
		bitset<N> _bs2;
	};

	void test_bit_set3()
	{
		int a[] = { 3, 4, 5, 2, 3, 4, 4, 4, 4, 12, 77, 65, 44, 4, 44, 99, 33, 33, 33, 6, 5, 34, 12 };

		twobitset<100> bs;
		for (auto e : a)
		{
			bs.set(e);
		}

		bs.print_once_num();
	}

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

解决步骤：

  • 100亿个整数会出现重复，整数的范围在 0~4294967295,因此实际只需要开辟 4294967295个比特位就行。即 0xFFFFFFFF。
  • 两张位图加起来为 85亿多比特位。
  • 使用两个位图，对应都是1就是交集。
	template<size_t N>
	class twobitset
	{
	public:
		void set(vector<int>& a, vector<int>& b)
		{
			for (auto e : a)
			{
				_bs1.set(e);
			}
			for (auto e : b)
			{
				_bs2.set(e);
			}
		}

		void print_union_num()
		{
			for (size_t i = 0; i < N; ++i)
			{
				if (_bs1.test(i) == true && _bs2.test(i) == true)
				{
					cout << i << endl;
				}
			}
		}

	private:
		bitset<N> _bs1;
		bitset<N> _bs2;
	};

	void test_bit_set4()
	{
		vector<int> a = { 3, 4, 5, 2, 3, 4, 4, 4, 4, 12, 77, 65, 44, 4, 44, 99, 33, 33, 33, 6, 5, 34, 12 };
		vector<int> b = { 3,4,5,12,23};

		twobitset<100> bs;
		bs.set(a, b);
		bs.print_union_num();
	}

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

解题步骤:

  • 类似,用两个位图记录4种转态,00:0次,01:1次,10:2次,11:三次即以上
template<size_t N>
class twobitset
{
public:

	void set(size_t x)
	{
		bool inset1 = _bs1.test(x);
		bool inset2 = _bs2.test(x);

		// 00
		if (inset1 == false && inset2 == false)
		{
			// -> 01
			_bs2.set(x);
		}
		else if (inset1 == false && inset2 == true)
		{
			// ->10
			_bs1.set(x);
			_bs2.reset(x);
		}
		else if (inset1 == true && inset2 == false)
		{
			// ->11
			//_bs1.set(x);
			_bs2.set(x);
		}
	}

	// 
	void print_num(vector<int>& a)
	{
		for (size_t i = 0; i < a.size(); ++i)
		{
			// 10
			if (_bs1.test(a[i]) == true && _bs2.test(a[i]) == false)
			{
				cout << a[i] << endl;
			}
			// 01
			else if (_bs1.test(a[i]) == false && _bs2.test(a[i]) == true)
			{
				cout << a[i] << endl;
			}
			// 00
			else if (_bs1.test(a[i]) == false && _bs2.test(a[i]) == false)
			{
				cout << a[i] << endl;
			}

		}
	}

private:
	bitset<N> _bs1;
	bitset<N> _bs2;
};

void test_bit_set5()
{
	vector<int> a = { 3,5, 2, 3, 4, 4, 4, 4, 12,12 , 77, 65, 44,44,  33, 33, 33, 34};
	//int a[] = { 3,3,3,3 };

	twobitset<100> bs;
	for (auto e : a)
	{
		bs.set(e);
	}

	bs.print_num(a);
}

}

布隆过滤器

布隆过滤器提出

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

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

布隆过滤器概念

布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概
率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存
在”，它是用多个哈希函数，将一个数据映射到位图结构中。相比于传统的 List、Set、Map 等数据结构，它更高效、占用空间更少，但是缺点是其返回的结果是概率性的，而不是确切的。

https://zhuanlan.zhihu.com/p/43263751/

布隆过滤器实现原理

1.HashMap 的问题

讲述布隆过滤器的原理之前，我们先思考一下，通常你判断某个元素是否存在用的是什么？应该蛮多人回答 HashMap 吧，确实可以将值映射到 HashMap 的 Key，然后可以在 O(1) 的时间复杂度内返回结果，效率奇高。但是 HashMap 的实现也有缺点，例如存储容量占比高，考虑到负载因子的存在，通常空间是不能被用满的，而一旦你的值很多例如上亿的时候，那 HashMap 占据的内存大小就变得很可观了。

还比如说你的数据集存储在远程服务器上，本地服务接受输入，而数据集非常大不可能一次性读进内存构建 HashMap 的时候，也会存在问题。

2.布隆过滤器数据结构

布隆过滤器是一个 bit 向量或者说 bit 数组，长这样：

在这里插入图片描述

如果我们要映射一个值到布隆过滤器中，我们需要使用多个不同的哈希函数生成多个哈希值，并对每个生成的哈希值指向的 bit 位置 1，例如针对值 “baidu” 和三个不同的哈希函数分别生成了哈希值 1、4、7，则上图转变为：

在这里插入图片描述Ok，我们现在再存一个值 “tencent”，如果哈希函数返回 3、4、8 的话，图继续变为：

在这里插入图片描述
值得注意的是，4 这个 bit 位由于两个值的哈希函数都返回了这个 bit 位，因此它被覆盖了。现在我们如果想查询 “dianping” 这个值是否存在，哈希函数返回了 1、5、8三个值，结果我们发现 5 这个 bit 位上的值为 0，说明没有任何一个值映射到这个 bit 位上，因此我们可以很确定地说 “dianping” 这个值不存在。

而当我们需要查询 “baidu” 这个值是否存在的话，那么哈希函数必然会返回 1、4、7，然后我们检查发现这三个 bit 位上的值均为 1，那么我们可以说 “baidu” 存在了么？答案是不确定，只能说 “baidu” 这个值可能存在。

这是为什么呢？答案跟简单，因为随着增加的值越来越多，被置为 1 的 bit 位也会越来越多，这样某个值 “taobao” 即使没有被存储过，但是万一哈希函数返回的三个 bit 位都被其他值置位了 1 ，那么程序还是会判断 “taobao” 这个值存在。

结论：

在：不准确，存在误判。
不在：准确，不存在误判。

3. 支持删除么

传统的布隆过滤器并不支持删除操作。但是名为 Counting Bloom filter 的变种可以用来测试元素计数个数是否绝对小于某个阈值，它支持元素删除。可以参考文章 Counting Bloom Filter 的原理和实现

布隆过滤器的应用场景

布隆过滤器能够快速的确认一个元素是否存在，但是存在误判。一些场景下可以允许出现误判，还有一些不允许出现误判。我们对这两种场景分别举例说明。
1.黑名单场景

场景：我们要记录用户信息，有一份黑名单，如果用户在黑名单里，那么就不记录该用户的信息。黑名单数量很大存放在数据库里，但是数据库访问很慢，如果用set记录，内存不够。

解决方法：

在内存里创建布隆过滤器，如果在那么再到数据库确认，因为“在” 存在误判 ，如果不在，直接返回。

优势：

set，map 空间大，可能存放不下黑名单。
布隆过滤器能减少访问数据库的次数，提高效率。
在这里插入图片描述
2.昵称是否被占用场景

场景：注册页面，快速输入提示昵称死否被占用。

在这种场景下是允许存在误判的。
在这里插入图片描述

如何选择哈希函数个数和布隆过滤器长度 - - 目的减少误判率

什么是误判？ 实际不存在的元素，被判断为存在。判断的结果是错误的。

很显然，过小的布隆过滤器很快所有的 bit 位均为 1，那么查询任何值都会返回“可能存在”，起不到过滤的目的了。布隆过滤器的长度会直接影响误报率，布隆过滤器越长其误报率越小。

另外，哈希函数的个数也需要权衡，个数越多则布隆过滤器 bit 位置位 1 的速度越快，且布隆过滤器的效率越低；但是如果太少的话，那我们的误报率会变高。

如下图：k 为哈希函数个数，m 为布隆过滤器长度，n 为插入的元素个数，p 为误报率。
在这里插入图片描述

如何选择适合业务的 k 和 m 值呢，这里直接贴一个公式：

在这里插入图片描述

例如：
假设k为3，即hash函数的个数为3，

k=m/n * 0.7
4.2n=m

即hash函数的个数为3时，布隆过滤器要开辟 4.2n个。

布隆过滤器的实现

1.哈希函数

struct HashBKDR
{
	// BKDR
	size_t operator()(const string& key)
	{
		size_t val = 0;
		for (auto ch : key)
		{
			val *= 131;
			val += ch;
		}

		return val;
	}
};

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

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

		return hash;
	}
};

2.布隆过滤器

注意：
STL 里 bitset存放在栈里，因此可能会导致栈溢出，我们把bitset对象转移到堆上就行。

// N表示准备要映射N个值
template<size_t N,
	class K = string, class Hash1 = HashBKDR, class Hash2 = HashAP, class Hash3 = HashDJB>
class BloomFilter
{
public:
	void Set(const K& key)
	{
		size_t hash1 = Hash1()(key) % (_ratio * N);
		//cout << hash1 << endl;

		_bits->set(hash1);

		size_t hash2 = Hash2()(key) % (_ratio * N);
		//cout << hash2 << endl;

		_bits->set(hash2);

		size_t hash3 = Hash3()(key) % (_ratio * N);
		//cout << hash3 << endl;

		_bits->set(hash3);
	}

	bool Test(const K& key)
	{
		size_t hash1 = Hash1()(key) % (_ratio * N);
		//cout << hash1 << endl;
		if (!_bits->test(hash1))
			return false; // 准确的

		size_t hash2 = Hash2()(key) % (_ratio * N);
		//cout << hash2 << endl;

		if (!_bits->test(hash2))
			return false; // 准确的

		size_t hash3 = Hash3()(key) % (_ratio * N);
		//cout << hash3 << endl;

		if (!_bits->test(hash3))
			return false;  // 准确的

		return true; // 可能存在误判
	}

	// 能否支持删除-> 
	void Reset(const K& key);

private:
	const static size_t _ratio = 5;
	// STL 里 bitset存放在栈里，因此可能会导致栈溢出，我们把bitset对象转移到堆上就行
	std::bitset<_ratio* N>* _bits = new std::bitset<_ratio* N>;
};

3.测试

测试 1

void TestBloomFilter1()
{
	BloomFilter<10> bf;
	string arr1[] = { "苹果", "西瓜", "阿里", "美团", "苹果", "字节", "西瓜", "苹果", "香蕉", "苹果", "腾讯" };

	for (auto& str : arr1)
	{
		bf.Set(str);
	}

	for (auto& str : arr1)
	{
		cout << bf.Test(str) << endl;
	}
	cout << endl << endl;

	string arr2[] = { "苹果111", "西瓜", "阿里2222", "美团", "苹果dadcaddxadx", "字节", "西瓜sSSSX", "苹果 ", "香蕉", "苹果$", "腾讯" };

	for (auto& str : arr2)
	{
		cout << str << ":" << bf.Test(str) << endl;
	}
}

测试2：测试误判率

void TestBloomFilter2()
{
	srand(time(0));
	const size_t N = 100000;
	BloomFilter<N> bf;
	cout << sizeof(bf) << endl;

	std::vector<std::string> v1;
	std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";
	// 插入一组数据
	for (size_t i = 0; i < N; ++i)
	{
		v1.push_back(url + std::to_string(1234 + i));
	}

	for (auto& str : v1)
	{
		bf.Set(str);
	}

	// 相似数据的误判率
	std::vector<std::string> v2;
	for (size_t i = 0; i < N; ++i)
	{
		std::string url = "http://www.cnblogs.com/-clq/archive/2021/05/31/2528153.html";
		url += std::to_string(rand() + i);
		v2.push_back(url);
	}

	size_t n2 = 0;
	for (auto& str : v2)
	{
		if (bf.Test(str))
		{
			++n2;
		}
	}
	cout << "相似字符串误判率:" << (double)n2 / (double)N << endl;

//   不相似字符串误判率
	std::vector<std::string> v3;
	for (size_t i = 0; i < N; ++i)
	{
		string url = "zhihu.com";
		url += std::to_string(rand() + i);
		v3.push_back(url);
	}

	size_t n3 = 0;
	for (auto& str : v3)
	{
		if (bf.Test(str))
		{
			++n3;
		}
	}
	cout << "不相似字符串误判率:" << (double)n3 / (double)N << endl;
}

4.布隆过滤器的删除

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

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

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

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

布隆过滤器优点

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

布隆过滤器缺陷

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

海量数据面试题

哈希切割

哈希切割将海量的数据通过哈希函数进行数据划分，相同哈希值的数据被归并到相同位置上。

1.给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？
解题步骤：

  • map来记录，空间消耗大，内存存放不下。
  • 哈希切割法：
    • 如下图，每次读取一个ip，将ip进行哈希取模求出i，然后将这个ip进入第i个小文件里。
    • 每个小文件存在不同种类的ip，但是相同的ip，一定进入同一个小文件里。
    • 此时，小文件可以加载到内存里，我们可以使用map<string,in> 统计每个小文件IP次数。每次统计完一个小文件就能求出此时小文件的最大次数的IP，释放map<string,int>。
    • 注意：小文件可能进入的ip数量比较多，小文件可能太大无法加载到内存，我们只需要再次将小文件进行哈希切割即可，当然此时哈希函数要改变一下。

在这里插入图片描述

2.与上题条件相同，如何找到top K的IP？如何直接用Linux系统命令实现？

解题步骤：

  • 建立一个K个<string,int>的小堆。
  • 与上题相同，先哈希切割，然后统计每个小文件，最好插入到小堆里。

3. 有3台集群服务器，如何通过id将数据存放到这个三台服务器上

解题步骤：

  • 如下图，给服务器进行编号，通过id求出哈希值。
  • 注意：如果服务器增多了怎么办？- 一致性哈希 ，服务器设计

在这里插入图片描述

布隆过滤器

1. 给两个文件，分别有100亿个query，我们只有1G内存，如何找到两个文件交集？分别给出精确算法和近似算法。

解题步骤：

  • 近似算法：
    • 提供一个布隆过滤器解决。
  • 精确算法：
    • 如下图，A和B两个文件，
    • 依次读取A文件中query，i = hash(query) % 1000 ,将这个query存进Ai小文件里。
    • B文件也如此操作。
    • 每次 ，编号相同的Ai 和 Bi 放到内存的set中找交集。

在这里插入图片描述

2. 如何扩展BloomFilter使得它支持删除元素的操作。

一致性哈希，服务器设计（了解）

2023框框
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2023框框

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值