目录
一、概念
1.1原理分析：
1.2效率分析：
二、模拟实现
2.1位图框架+初始化空间
2.2映射
2.3清零
2.4判断
2.5测试代码
三、位图扩展应用
一、概念
位图，本质上也是一个数组，通过哈希思想构造的一种数据结构，他提现的哈希思想是整数与比特位的映射，通过比特位来代表某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在。
通过一道经典题来引入如何模拟实现位图结构。
给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。【腾讯】
方法1：遍历，时间复杂度O(N)
方法2：排序O(N*logN)+二分查找O(logN)，时间复杂度O((N+1)*logN)
这两种方法看似都行，但是有一个问题的是40亿个整数大小，每个整形占4个字节，40亿个整数占160亿个字节，而1GB ≈ 10亿个字节，所以40亿个整数≈16GB，而16GB是大于正常的内存大小，我们也无法在内存中开16GB大小的空间。所以，该40亿个数据是存放在文件当中，但是也无法直接导入到内存当中，那么为了解决该问题，就可以采用映射的方式，将数据映射到位图中，且位图的大小是不超过内存的大小。至于原理是什么，接下来进行解释。
方法3：位图
1.1原理分析：
将每个整数想象成一个比特位，对于位图来说，它是个数组，目的就是要将这些整数存储到数组中去，也就是将比特位存储到数组中去，
那么数组存储的数据类型又是什么，只能是整形，如果是char类型，根本存不下，其他类型又不符合，接着将数组中每个整数当成32个比特位去理解，
所以最终目的是将比特位映射到数组中的对应整数中的32个比特位之中，也就是将整数映射到数组中对应整数的32个比特位之中，并将映射位置设为1，所以就可以通过判断映射到32个比特位的对应位置是1或者0来确定该整数是否存在。示意图；
通过该图，可以更清晰的了解是如何发生映射的，可以发现，数组中存储的仍然是整数，但是要把整数当成32个比特位去理解，虽然映射后，数组中的整数值是改变了，但是所看的根本就不是该整数值，而是整数对应的比特为是1还是0的状态来判断要映射的整数是否存在。
1.2效率分析：
那么这样算下来，40亿个数据映射到数组中的时间复杂度是O(N),但是对于该16GB的大小，对于数组来说就只要开16GB/32 = 0.5G 大小的空间，且内存是完全够开的，这就是位图体现的作用。
位图就是个以空间换时间的做法，但同时位图有自己的缺陷，就是只能针对整型数据，数据量大，整数在不在的问题。而对于其他数据类型不支持，那么对于这一问题，布隆过滤器可以解决，这在下一章节将解决。
现在就来模拟实现一下位图。
二、模拟实现
2.1位图框架+初始化空间
对于位图，需要容纳海量数据，判断数据是否存在，所以采用的是非类型模板参数。
假设整形个数据个数为N，那么对于位图而言需要开多大空间呢？
是 N/32个吗？ 并不是，对于刚好是32的倍数的确实满足，但对于不能刚好取整的就要多开一个，即使是刚好取整，多开32个比特位空间也不足挂齿。所以最终开的空间是 N/32 + 1个大小空间。
template<size_t N>
class bitset
{
public:
bitset()
{
_bst.resize(N / 32 + 1);
}
private:
vector<int> _bst;
};2.2映射
对于映射，在概念中，也已经简明扼要，这就不在过多阐述。
void set(size_t x)
{
int i = x/32;//在第几个整形
int j = x % 32;//在这个整形的第几个比特位
_bst[i] |= (1 << j);//将该位置设置为1
}2.3清零
对于映射完后的数据，如果不想要了，就可以清理调，那么对此该如何操作了。其实只需要更改一下位操作即可，即_bst[i] &= ~(1<<j);示意图：
实现：
void reset(size_t x)
{
int i = (x >> 5);
int j = x % 32;
_bst[i] &= ~(1 << j);//将对应映射位置清0
}2.4判断
同理只需要更改为操作判断该为是否为1即可
实现：
bool test(size_t x)
{
int i = (x >> 5);
int j = x % 32;
return _bst[i] & (1 << j);//测试该整数映射位置是否为1，即判断整数在不在
}2.5测试代码
//MyBitSet.h
#include <iostream>
#include <vector>
using namespace std;
namespace bit
{
template<size_t N>
class bitset
{
public:
bitset()
{
_bst.resize(N / 32 + 1);
}
void set(size_t x)
{
int i = x/32;//在第几个整形
int j = x % 32;//在这个整形的第几个比特位
_bst[i] |= (1 << j);//将该位置设置为1
}
void reset(size_t x)
{
int i = (x >> 5);
int j = x % 32;
_bst[i] &= ~(1 << j);//将对应映射位置清0
}
bool test(size_t x)
{
int i = (x >> 5);
int j = x % 32;
return _bst[i] & (1 << j);//测试该整数映射位置是否为1，即判断整数在不在
}
private:
vector<int> _bst;
};
}测试：
#include "MyBitSet.h"
int main()
{
bit::bitset<0xffffffff> bst;
int arr[] = { 1,3,7,4,12,16,19,13,22,18 };
for (size_t i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
bst.set(arr[i]);
}
cout << bst.test(7);
return 0;
}输出结果：
三、位图扩展应用
1.给定100亿个整数，设计算法找到只出现一次的整数？
这里直接说解法了，用两个位图来实现，对于这100一个整数可能出现重复的数，那么可以分三种情况，出现0次，1次，2次及以上，那么可以用位图来表示的情况是：
出现0次：0 0
出现1次：0 1
出现2次及以上：1 0，
100亿个整数大约1.25GB,构造两个分别为2GB的位图即可，这样内存开了4GB的空间，也是够的。
代码实现，对于位图的代码，前面已经实现了，这里就直接使用了：
template<size_t N>
class two_bitset
{
public:
void set(size_t x)
{
if (_bst1.test(x) == false && _bst2.test(x) == false)//出现1次
{
_bst2.set(x);
}
else if (_bst1.test(x) == false && _bst2.test(x) == true)//出现2次
{
_bst1.set(x);//1
_bst2.reset(x);//0
}
}
void PrintOnce()
{
for (int i = 0; i < N; i++)
{
if (_bst1.test(i) == false && _bst2.test(i) == true)
{
cout << i << endl;;
}
}
}
private:
bitset<N> _bst1;
bitset<N> _bst2;
};测试：
#include "MyBitSet.h"
int main()
{
bit::two_bitset<100> tbst;
int arr[] = { 1,3,3,7,4,12,12,16,16,19,13,13,22,22,18 };
for (auto e : arr)
{
tbst.set(e);
}
tbst.PrintOnce();
return 0;
}输出结果：
2.给两个文件，分别由100亿个整数，我们只有1G内存，如何找到两个文件交集？
方案一：整型的范围是确定的，如果按大小算大约为2GB，映射到位图中，位图只需开2GB/32 =1/16,所以构造一个位图开0.5G是完全够用的，虽然有100亿个数据，但都脱离不开整型的范围，必然会有重复，且位图会进行去重，所以0.5G必然够用。接着，将一个文件的数据映射到这个位图，再判断另一个文件的数据在不在位图中即可。
方案二：构造两个位图，每个位图开0.5G个内存，分别将两个文件中的数据映射到两个位图中，进行按位与比较即可。
3.1个文件有100亿个整数，1G内存，设计算法找到出现次数不超过2次的所有整数
这跟第一个情况是类似的，分析出现0次，1次，2次，3次及以上，这里就不在实现了。
end~
