C++ 哈希的应用【位图】

✨个人主页： 北 海
所属专栏： C++修行之路
操作环境： Visual Studio 2022 版本 17.6.5

---

---

前言

位图（bitset）是一种特殊的数据结构，仅仅依靠 0、1 表示当前位置是否有数据存在，常用于对查找速度和存储空间有着高要求的场景中，除此之外，位图还可以配合宏定义，实现同时传递多个参数，比如系统调用 open，其中的参数2（打开方式）就是一个简单的位图结构

棋盘中棋子表示当前位置是否被占用

---

️正文

位图可以用来解决实际问题，比如下面这道面试题就需要借助位图

1、问题一

给出 40 亿个不重复的无符号整数（无序），再给出一个无符号整数，判断此数是否存在于 40 亿个无符号整数中

这是一道来自【腾讯】的面试题，题目要求很简单：判断给出的数是否存在

如果按照常规思路：存储数据，排序后查找，首先得先有一个足够大的数组存储这些数据

一个无符号整型大小是 4 字节，40 亿个无符号整型就是：40 * 4 = 160 亿字节，转换一下可知：大约需要 16 GB 的空间（10 亿字节约占 1 GB 空间）

还好，现在的笔记本普遍内存都有 16 GB，但是总不能把这些空间全部用来存数据吧，操作系统不跑了？编译软件不运行了？显然这种方法不现实

可能有的人觉得加装内存条就行了，确实，解决现在这个问题可以，但如果把数据量提至 80亿 呢？还不是照样不够，因此 直接在运行时开辟空间存储数据不可取

此时有人想到了第二种方法：既然内存不够，那我把数据持久化（写入文件）总行了吧，查找的时候读取文件就行了吧

当然可以，把这点数据存储在硬盘中随便存，读取也很方便，无非就是文件流操作嘛，但是此时有了一个新的问题：时间问题

总所周知，IO 是十分影响效率的，在 《Linux 进程信号【信号产生】》中我们就做过相关实验，得出取消 IO 前后，性能差距约 1w 倍，换作文件读取，可想而知得有多慢

并且由于数据无序，只能暴力遍历，耗费时间： 存储数据 + 遍历数据 + IO 的额外开销，这个方案也是不可取的

既然是腾讯的题，那其中肯定有坑，常规思路是无法很好地解决问题的，此时就需要借助我们今天的主角 位图 了

---

2、位图概念

位图 是个啥？位图 是 哈希思想 的一种应用，哈希表 映射数据时使用的是 vector，而 位图 映射数据时使用的是 比特位，没错，就是只能表示 0 和 1 的比特位（使用直接定址法，只能判断整型）

为什么 位图 能解决这种海量数据问题？
因为位图是哈希的应用，查找速度非常快，并且因为位图使用的是最小的单元：比特，空间利用率极高，而这就是【腾讯】这道面试题的最优解

解题思路：首先 40 亿个无符号的整数，重点在 无符号，这就意味着借助下标可以映射所有的数，无符号整型的最大值为 UINT_MAX（4294967295），这 40 亿个数据的范围 [0, UINT_MAX]

题目不过是 验证某数是否存在，因此我们可以直接创建一个大小为 UINT_MAX 的 位图 结构，将 40 亿个数统统存进去（重复数据不影响），存储完毕后，直接利用 位图 的特性：极速查找（哈希映射），就可以在 O(1) 时间内解决问题

至于内存占用，UINT_MAX 大约相当于 512 mb，就这点内存占用，随便给（某鹅厂应用占用内存随便都是几百兆）

位图的工作原理

在 C++ 中提供了位图结构 bitset（需要包含头文件 ）

---

3、位图的模拟实现

注：模拟实现时，只是简单实现，旨在理解位图的原理，与库中的 bitset 存在较大差异

3.1、基本思路

位图 的原理其实十分简单，本质上就是 开辟了一个大小为 N，类型为 Type 的数组

获取值位于哪一个下标中：Val / TypeSize
获取值位于哪一个具体比特位：Val % TypeSize

注：Val 是待 设置/重置/判断 的值，TypeSize 是类型 Type 所占比特位数

感觉有点像 哈希桶（使用开散列实现的哈希表），首先是找到位于哪一个 桶 中，然后去 桶 中遍历查找，不过这里的 桶 是 下标，表示属于数组中的哪一个元素，桶中的值 表示元素中的 比特位

千言万语不如一张图说明问题：

所以我们模拟实现的 位图 本质上就是一个 vector 的数组，不过此时使用的是 比特位

结构如下：

//非类型模板参数，这里的含义是比特位的总个数
template<size_t N>
class bitset
{
	enum { SIZE = 8 };	//char 的大小
public:
	//初始化（开辟足量的空间）
	bitset()
	{
		//除 8 是因为此时基本类型为 char
		//加 1 是为了避免不能被整除时，造成比特位丢失，宁可多开，也不能缺失
		_bits.resize(N / SIZE + 1, 0);
	}

	//其他默认成员函数不必写了，会自动调用 vector 的
private:
	vector<char> _bits;
};

为什么要选 char ？
在 C语言 阶段，我们学习过一个知识点：大小端字节序，对于多字节的数据类型，诸如 int 存在大小端问题，比如 int a = 1
在大端机器中为：00 00 00 01
而在小端机器中为：01 00 00 00
不同机器中的二进制位排列方式略有差异（后续位运算依赖于二进制的排列方式），为了确保兼容性，我们可以直接使用 char，因为它就 1 字节（8 比特），不存在大小端字节序问题；并且 8 比特位足够少，便于学习理解位图结构

3.2、set

首先来看看 如何添加数据

位图 中没有直接插入数据的概念，取而代之的是将数据对应的比特位置为 1

假设现在 位图 Bit 的大小为 32 bit，待设置的数据为 28

首先获取具体的下标：i = 28 / 8 = 3
其次获取具体的比特位：j = 28 % 8 = 4

现在只需要把 Bit[3] 元素的第五个比特位（下标为 4）置为 1 即可成功设置 数据 28

这里考虑冗余的情况，即使目标位置为 1，照样置为 1

想要把某个比特位置为 1 可以使用 | 进行位运算：遇 1 变 1

因此 set 数据 28 时可以这样做：Bit[3] |= (1 << 4)，如下图所示

将上述逻辑转化为代码，可得到 set 函数的实现：

//设置数据
void set(size_t val)
{
	//首先获取下标 i 
	size_t i = val / SIZE;

	//然后获取具体比特位 j
	size_t j = val % SIZE;

	//置 1
	_bits[i] |= (1 << j);
}

注意： 此处的具体比特位 j 并非代表 _bits[i] 元素中比特位的下标，而是 下标 + 1，比如 j = 4，表示的是 _bits[i] 元素中的第 4 个比特位，此时的比特位下标为 3，因为下标是从 0 开始的

3.3、reset

有 设置 就要有 重置（取消），也就是 reset

设置 的目的是 将指定的比特位置 1，而 重置 的目的是 把指定的比特位重置 0

至于获取 下标 和 比特位，和 设置 一样，或者说 位图 中的基本操作都离不开这两步

首先获取具体的下标：i = 28 / 8 = 3
其次获取具体的比特位：j = 28 % 8 = 4

将某个比特位置为 0，可以使用 & 进行位运算：遇 0 变 0

下面把之前 设置 的 28 进行 重置：Bit[3] &= ~(1 << 4)，如下图所示

reset 的代码实现如下：

//重置数据
void reset(size_t val)
{
	//首先获取下标 i 
	size_t i = val / SIZE;

	//然后获取具体比特位 j
	size_t j = val % SIZE;

	//置 0
	_bits[i] &= ~(1 << j);
}

这里不必担心 优先级问题，因为所有的 xxx= 优先级 都是很低的，所以可以保证计算出 ~(1 << j) 后才对 _bits[i] 进行 与等 运算

3.4、test

位图 中的必备功能：判断某个数据是否位于位图中（test）

这是 位图 的核心功能，毕竟 位图 的主要作用就是 判断某个数在不在

• 存在：对应的比特位为 1
• 不存在：对应的比特位为 0

一样的老套路：获取 下标 和 比特位，这里依旧请出老演员 28

首先获取具体的下标：i = 28 / 8 = 3
其次获取具体的比特位：j = 28 % 8 = 4

如何判断在不在？
简答，如果存在的话，对应的比特位肯定为 1，我们只需要把该位置的其他比特位置为 0，再判断该元素是否为 0 即可

可以这样操作：Bit[3] & (1 << 4)

test 的代码实现如下：

//判断是否存在
bool test(size_t val) const	//这里直接使用 const 修饰，避免被修改
{
	//首先获取下标 i 
	size_t i = val / SIZE;

	//然后获取具体比特位 j
	size_t j = val % SIZE;

	return _bits[i] & (1 << j);	//返回的是临时变量，真正的元素不会被修改
}

注意： 此时不能使用 &=，不能改变原来的比特位状态，因为这里只是判断是否存在！

3.5、代码测试

切忌 纸上谈兵，下面来看看 位图 是否有用

void testBitSet1()
{
	Yohifo::bitset<10> Bit;	//创建可容纳 [0, 10]数值 的位图
	for (int i = 0; i <= 10; i++)
	{
		//这里设置奇数
		if (i % 2) 
			Bit.set(i);
	}

	//判断一下 [0, 10] 有多少数存在
	for (int i = 0; i <= 10; i++)
	{
		if (Bit.test(i)) 
			cout << i << "存在" << endl;
		else 
			cout << i << "不存在" << endl;
	}
}

程序正常运行

为什么之前开空间时要 +1？
一是为了避免不能被整除时，比特位的丢失，比如 10 / 8 = 1，如果不 +1，显然 第9、第10 个比特位都没办法使用，所以 +1 多开一点空间可以避免这个问题。二是即使能被整除，也要保证 N 也能正常存入，比如 16 / 8 = 2，第 1~20 个比特位都可用，数据范围为 [0, 20)，为了使 20 也能被顺利使用，可以多开一个空间。总的来说，有一点点浪费，但绝对是 利大于弊

接下来简单验证下存 40 亿个无符号整数只需要 约 512 mb 空间

注：传递 -1 时，因为参数类型为 size_t ，会隐式类型转换为 UINT_MAX；当然，直接传递 UINT_MAX 也是可以的

void testBitSet2()
{
	Yohifo::bitset<-1> Bit;	//创建可容纳 [0, UINT_MAX]数值 的位图
	//Yohifo::bitset Bit;	//创建可容纳 [0, UINT_MAX]数值 的位图

	while (true);	//查看任务管理器中的内存占用情况
}

所以说，用 位图 可以解决 【腾讯】的那一道海量数据面试题，同时也是最优解，查找速度为 O(1)

注意： 此时的测试环境为 x86，x64 环境下会报错

---

4、问题二

还有一个与开篇的问题相似的姊妹问题

给出 100 亿个不重复的无符号整数（无序），设计算法找到其中只出现一次的数

数据量变大了一倍多，没事，再多开一点，需要约 1.2 GB 的内存空间，此时内存不是问题的重点，重点在于如何设计 算法

对于这种在两堆数中找只出现一次的数，避免不了同时遍历两堆数，所以我们需要 2 个 位图，并且大小都为 100 亿，总占用约 2.4 GB 的内存空间

解题思路：二进制，我们把 位图1 看作高位，位图2 看作低位，第一次出现时，给 位图2 进行设置，后续第二次乃至第N次出现时，重置 位图2，设置 位图1；经过这样操作后，只要是 位图2 为 1，就说明该数仅出现了一次

约定：

• 0 0 没有出现
• 0 1 只出现一次
• 1 0 出现多次

转换成代码如下（这里直接封装成一个类了）

template<size_t N>
class twoBitSet
{
public:
	void twoSet(size_t val)
	{
		//约定：1 0 表示出现过多次（位图2不存在值），0 1 表示只出现过一次（位图2存在值）
		if (_bs1.test(val) == false && _bs2.test(val) == false)
			_bs2.set(val);	//第一次出现，位图2 置 1
		else if (_bs1.test(val) == false && _bs2.test(val) == true)
		{
			//此时为第二次或更多次出现，往前进位
			_bs1.set(val);
			_bs2.reset(val);
		}
	}

	void print()
	{
		//输出只出现一次的数字
		//判断 位图2 就好了
		for (int i = 0; i <= N; i++)
		{
			if (_bs2.test(i) == true)
			{
				std::cout << i << " " << std::endl;
			}
		}
	}

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

通过下面这个 demo 测试一下

void testTwoBitSet1()
{
	int a[] = { 3, 45, 53, 32, 32, 43, 3, 2, 5, 2, 32, 55, 5, 53, 43, 9, 8, 7, 8 };
	Yohifo::twoBitSet<100> Bits;	//最大的值不过 100，所以 100 足够了

	for (auto e : a)
	{
		Bits.twoSet(e);
	}

	Bits.print();
}

这样就可以解决问题了

5、问题三

给两个文件，分别有 100 亿个整数（无序），我们只有 1 GB 内存，如何找到两个文件交集？

此时只有 1 GB 的可用空间，意味着我们只有一个 位图（100 亿整数中有大量重复的数据，至多有 42 亿多个数，所以 1 GB 空间足够了）

解决方案一：先读取其中一个文件，将数据设置入 位图 中；然后再读取另一个文件，此时是判断第二个文件中的数据是否存在于 位图 中，如存在，就说明是交集

这种方案面临一个问题：存在重复的值，比如 文件1{1, 2,}，文件2{1, 3, 1, 2}，此时得出的交集为 {1, 1, 2}，交集中是没有重复值的，想要解决这个问题有两个方法：

1. 初步得到交集后进行去重，就能得到最终的交集
2. 判断该数是否为交集，如果是，记录数值后，把位图中的值给 reset，这样即使后续有重复的值，也不会被纳入交集了

解决方案二（无内存空间限制的情况下）：直接搞两个位图，把两个文件都读进去，然后同时遍历，通过 & 位运算求出交集就行了

这种方案很暴力，对空间要求较高，且每次遍历的时间都是恒定的（42 亿次）

抛开题目中的内存空间限制，解决方案一、二各有自己的使用场景

• 数据量过大时，比如 42 亿或更多，适合使用方案二（个数相关），因为 不管值再大，整数不过 42 亿多个，方案二在进行遍历时，也只需要遍历 42 亿次，是比较合适的
• 当数据量较小时，比如 1 亿，就可以考虑方案一了（值相关），原因很简单：节省空间的同时不至于遍历太多次，方案一遍历时，遍历的是数据量，只需要遍历 1 亿次

奈何本题有内存空间限制，还是老老实实的使用方案一吧

6、问题四

一个文件有 100 亿个 int，1 GB 内存，设计算法找到出现次数不超过 2 次的所有整数

这道题是 问题二 的变形，只需要推广 约定 即可，照样使用两个 位图

约定：

• 一次都没有出现：0 0
• 只出现一次：0 1
• 出现两次：1 0
• 出现三次或更多：1 1

把代码稍微修改下，可得出代码

template<size_t N>
class twoBitSet
{
public:
	void twoSet(size_t val)
	{
		//约定: 0 0 表示没有出现, 0 1 表示只出现过一次, 1 0 表示出现两次, 1 1 表示出现三次或更多
		if (_bs1.test(val) == false && _bs2.test(val) == false)
			_bs2.set(val);	//第一次出现，位图2 置 1
		else if (_bs1.test(val) == false && _bs2.test(val) == true)
		{
			//此时为第二次出现, 往前进位
			_bs1.set(val);
			_bs2.reset(val);
		}
		else if (_bs1.test(val) == true && _bs2.test(val) == false)
		{
			//出现三次或更多
			_bs2.set(val);
		}
	}

	void print()
	{
		//输出只出现一次的数字
		//判断 位图1 及 位图2
		for (int i = 0; i <= N; i++)
		{
			if ((!_bs1.test(i) && _bs2.test(i)) || (_bs1.test(i) && !_bs2.test(i)))
			{
				std::cout << i << " " << std::endl;
			}
		}
	}

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

借助 demo 进行简单测试

void testTwoBitSet2()
{
	int a[] = { 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 5, 6, 7, 8, 8 };
	Yohifo::twoBitSet<100> Bits;	//最大的值不过 100，所以 100 足够了

	for (auto e : a)
	{
		Bits.twoSet(e);
	}

	Bits.print();
}

不得不说，二进制进位统计的思想还是很好用的

---

7、位图小结

位图 是一种十分特殊的数据结构，其主要依靠 0 和 1 表征状态，结合 哈希 的映射思想，即保证了 速度，又保证了 空间

位图 的优点如下：

• 速度极快 O(1)
• 节省空间 使用粒度最细的比特位

位图 的缺点如下：

• 只能映射整型
• 对于浮点符、字符串等数据无法做到很好的映射

映射字符串时，主要是无法确保唯一性，但可以判断字符串 是否存在，这就是 哈希 的另一个应用场景：布隆过滤器

弗雷尔卓德之心 布隆

---

总结

以上就是本次关于 C++ 哈希的应用【位图】的全部内容了，在本文中，首先引入了一道来自【腾讯】的海量数据面试题，明确需要使用 位图 解决问题，简单模拟实现位图之后，又引入了几道海量数据面试题，进一步加深对 位图 结构的认识，位图 还可以用来实现其他结构，比如 布隆过滤器，常用于字符串快速判断，详细内容移步下一篇文章

---

相关文章推荐

C++ 进阶知识

C++【哈希表的完善及封装】

C++【哈希表的模拟实现】

C++【初识哈希】

C++【一棵红黑树封装 set 和 map】

C++【红黑树】

C++【AVL树】

C++【set 和 map 学习及使用】

C++【二叉搜索树】

C++【多态】

C++【继承】