位图｜布隆过滤器模拟实现｜STL源码剖析系列｜手撕STL

今天博主给大家带来位图和布隆过滤器的模拟实现。

---

前言

那么这里博主先安利一下一些干货满满的专栏啦！

手撕数据结构https://blog.csdn.net/yu_cblog/category_11490888.html?spm=1001.2014.3001.5482这里包含了博主很多的数据结构学习上的总结，每一篇都是超级用心编写的，有兴趣的伙伴们都支持一下吧！
算法专栏https://blog.csdn.net/yu_cblog/category_11464817.html这里是STL源码剖析专栏，这个专栏将会持续更新STL各种容器的模拟实现。

STL源码剖析https://blog.csdn.net/yu_cblog/category_11983210.html?spm=1001.2014.3001.5482

---

位图和布隆过滤器

位图

位图（Bitmap）通常指的是使用位（bit）作为最小单位存储和处理数据的数据结构或技术。位图可以用来表示一组二进制标志或位状态，并且可以有效地压缩存储大量布尔信息。

位图最常见的用途之一是表示集合或标志的状态。例如，可以使用位图来表示一个包含多个元素的集合，其中每个元素对应位图中的一个位。如果位的值为1，则表示该元素在集合中；如果位的值为0，则表示该元素不在集合中。

在C语言中，可以使用无符号整数类型（如unsigned int、unsigned long）或数组来实现位图。

布隆过滤器

布隆过滤器（Bloom Filter）是一种用于高效判断一个元素是否属于一个集合的概率型数据结构。它基于位图（Bitmap）的概念，但使用了多个哈希函数来实现更高的查找效率。

布隆过滤器由一个位数组和多个哈希函数组成。初始时，所有位数组的值都被设置为0。当要向布隆过滤器中插入一个元素时，该元素经过多个哈希函数的计算，得到多个哈希值。然后将对应的位数组位置设置为1。当需要判断一个元素是否在集合中时，同样经过多个哈希函数的计算，检查对应的位数组位置是否都为1。如果有任何一位为0，则可以确定该元素不在集合中；如果所有位都为1，则表示该元素可能在集合中（存在误判的概率）。

布隆过滤器的主要优势是其高效的插入和查询操作。它的时间复杂度是O(k)，其中k是哈希函数的数量，通常是一个较小的常数。布隆过滤器的空间复杂度也相对较低，只受到位数组的大小和哈希函数数量的影响。

然而，布隆过滤器也有一些限制。首先，存在一定的误判率，即在判断元素是否在集合中时，有一定的概率会出现错误的判断。其次，无法删除已插入的元素，因为删除操作会影响其他元素的判断结果。因此，布隆过滤器适用于对查询速度要求较高、可以容忍一定误判率的场景，如缓存、防止重复操作等。

需要根据具体的应用场景和数据特点来选择使用布隆过滤器，并在设计时注意误判率的控制和容量估算，以达到最佳效果。

BitSet.h

#pragma once

#include<vector>
#include<iostream>
using namespace std;

//位图特点
//1.快、节省空间
//2.相对局限，只能映射处理整型

//用char -- 一个char位置存8位
//怎么找位置，比如20
//20/8=2表示放在第几个char上
//20%8=4表示放在这个char的第几个位置
namespace yfc
{
	template<size_t N>
	class bit_set
	{
	public:
		bit_set()
		{
			_bits.resize(N / 8 + 1, 0);//+1可以保证空间一定够
		}
		void set(size_t x)
		{
			//把x的位置设置成1
			size_t i = x / 8;
			size_t j = x % 8;
			//怎么把_bit[i]的第j位弄成1呢
			//用一个或运算！
			_bits[i] |= (1 << j);
		}
		void reset(size_t x)
		{
			//把x的位置设置成0
			size_t i = x / 8;
			size_t j = x % 8;
			_bits[i] &= ~(1 << j);
		}
		bool test(size_t x)
		{
			//看这一位是0还是1
			size_t i = x / 8;
			size_t j = x % 8;
			return _bits[i] & (1 << j);
		}
	private:
		vector<char> _bits;
	};
	void test_bit_set1()
	{
		bit_set<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()
	{
		//这三种写法都可以
		bit_set<-1>bs1;//-1的写法是最好的 -- -1对应的size_t就是全1
#if 0
		bit_set<0xffffffff>bs2;
		bit_set < 1024 * 1024 * 1024 * 4 - 1> bs3;
#endif
		//我们打开看任务管理器 -- 是可以看到是512MB左右的
	}

	//面试题2
	//我们用两个位图就行 -- 两个位图对应位置一起表示状态
	template<size_t N>
	class twobitset
	{
	private:
		bit_set<N>_bs1;
		bit_set<N>_bs2;
	public:
		void set(size_t x)
		{
			//要先判断一下
			bool inSet1 = _bs1.test(x);
			bool inSet2 = _bs2.test(x);
			if (inSet1 == false && inSet2 == false)
			{
				//00->01
				_bs2.set(x);
			}
			else if (inSet1 == false && inSet2 == true)
			{
				//01->10
				_bs1.set(x);
				_bs2.reset(x);
			}
		}
		void print_once_num()
		{
			for (size_t i = 0; i < N; i++)
			{
				if (_bs1.test(i) == false && _bs2.test(i) == true)
				{
					cout << i << " ";
				}
			}
			cout << endl;
		}
	};
	void test_bit_set3()
	{
		int a[] = { 1,2,3,4,5,6,7,8,9,10,12,10,9,8,6,5,3,2,1 };
		twobitset<100>bs;
		for (auto e : a)
		{
			bs.set(e);
		}
		bs.print_once_num();
	}
	//面试题3
	//也是用两个位图
	//第一个是文件1的映射
	//第二个是文件2的映射
	//映射位都是1的值就是交集

	//面试题4
	//其实和2是一样的，00/01/10/11就行
}

BloomFilter.h

#pragma once

//布隆过滤器

#include"BitSet.h"
#include<algorithm>
#include<string>
using namespace std;

namespace yfc
{
	template<class K = string>
	struct HashBKDR
	{
		size_t operator()(const K& key)
		{
			size_t val = 0;
			for (auto ch : key)
			{
				val *= 131;
				val += ch;
			}
			return val;
		}
	};
	template<class K = string>
	struct HashAP
	{
		size_t operator()(const K& 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;
		}
	};
	template<class K = string>
	struct HashDJB
	{
		size_t operator()(const K& key)
		{
			size_t hash = 5381;
			for (auto ch : key)
			{
				hash += (hash << 5) + ch;
			}
			return hash;
		}
	};

	template<size_t N, class K = string,
		class Hash1 = HashBKDR<string>,
		class Hash2 = HashAP<string>,
		class Hash3 = HashDJB<string>>
	class BloomFilter
	{
	private:
		const static size_t _ratio = 5;
		bit_set<_ratio* N> _bits;
		//如果使用std::bitset
		//考虑放到堆上new一个
		//因为std::bit有个隐藏的bug会把栈撑爆
	public:
		void set(const K& key)
		{
			size_t hash1 = Hash1()(key) % (_ratio * N);
			_bits.set(hash1);
			size_t hash2 = Hash2()(key) % (_ratio * N);
			_bits.set(hash2);
			size_t hash3 = Hash3()(key) % (_ratio * N);
			_bits.set(hash3);
		}
		bool test(const K& key)
		{
			size_t hash1 = Hash1()(key) % (_ratio * N);
			if (!_bits.test(hash1))return false;
			size_t hash2 = Hash2()(key) % (_ratio * N);
			if (!_bits.test(hash2))return false;
			size_t hash3 = Hash3()(key) % (_ratio * N);
			if (!_bits.test(hash3))return false;

			return true;//可能存在误判 -- 上面的不在是准确的
		}
	};
	void testBloomFilter1()
	{
		BloomFilter<10>bf;
		string arr[] = { "苹果","西瓜","阿里","美团","苹果","字节","西瓜","苹果","香蕉","苹果","腾讯" };
		for (auto& str : arr)
		{
			bf.set(str);
		}
		for (auto& str : arr)
		{
			cout << bf.test(str) << endl;
		}
	}
	//测误判率的性能测试
	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;
	}
}