位图|布隆过滤器模拟实现|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 intunsigned long)或数组来实现位图。

布隆过滤器

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

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

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

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

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

BitSet.h

#pragma once

#include
#include
using namespace std;

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



//用char -- 一个char位置存8位
//怎么找位置,比如20
//20/8=2表示放在第几个char上
//20%8=4表示放在这个char的第几个位置
namespace yfc
{
	template
	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 _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
	class twobitset
	{
	private:
		bit_set_bs1;
		bit_set_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
#include
using namespace std;



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

	template,
		class Hash2 = HashAP,
		class Hash3 = HashDJB>
	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 bf;
		cout << sizeof(bf) << endl;

		std::vector 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 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 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;
	}
}

你可能感兴趣的:(STL源码剖析,手撕数据结构,C++深度剖析,c++,开发语言)