501位图bitmap

最新推荐文章于 2024-08-03 10:57:20 发布

keepgulp

最新推荐文章于 2024-08-03 10:57:20 发布

阅读量506

点赞数

CC 4.0 BY-SA版权

分类专栏：算法知识

本文链接：https://blog.youkuaiyun.com/dongqing0812/article/details/38112501

算法知识专栏收录该内容

28 篇文章

订阅专栏

题目：

已知某个文件内包含一些电话号码，每个号码为8位数字，统计不同号码的个数。

用bitmap解决这种问题，也就是说：

每一个电话号码被映射到了不同的位。

例如：

61234567 对应位 0x00001000

61234568 对应位 0x0001 0000

这样，每一个电话号码也就有了它自己的唯一标识，而且这个标识只占用1位，如果电话号码被统计过，这个位就标识为1，否则标识为0。

最后，通过统计bitmap中被标记为1的个数，就能统计出来不同号码的个数。

已知电话号码是8位，于是相当于范围是从00000000 ---> 9999 9999，这样无非需要 1亿个bit，也就是95.3M的内存。

映射函数怎么搞？每一个电话号码都要对应一个位，怎么让它们彼此对应起来呢？

这个问题其实不难解决：

电话号码00000000为最低位的标记，也就是0x0000.......000001。

那么电话号码00000001就应该是 0x0000.....0000010。

于是电话号码00000002就是0x0000....0000100。

电话号码就是1这个数字左移位所应该对应的次数。

用一个int型的数组来存bitmap，于是每一个元素就是四个字节，对应32位。

现在，用电话号码记作P。

P / 32 就是应当标记该号码的bitmap数组下标，P mod 32 就是1这个数字对应的左移次数，最后，左移完的结果和当前数组下标的记录按位或，over。

#include<iostream>
#include<memory.h>

using namespace std;
int const nArraySize = 100000000 / (sizeof(int)*8) + 1;
int BitMap[nArraySize];

void MapPhoneNumbertoBit(int number)
{
	int position = number / (sizeof(int)*8);
	BitMap[position] |= 0x00000001<< number % (sizeof(int)*8);//number/32就是这个电话号码对应在BitMap中的下标， number mod 32 就是需要在该段左移的次数。
}

int StatisticalPhoneNumber(char phones[][9], int length)
{
	memset(BitMap,0,nArraySize* sizeof(int));
	for(int i=0;i<length;i++)
	{
		int number = atoi(phones[i]);
		MapPhoneNumbertoBit(number);
	}

	int sumNumber = 0;

	for(int i=0;i<nArraySize;i++)
	{
		for(int j=0;j<(sizeof(int)*8);j++)
		{
			if((BitMap[i] & 0x00000001<<j) == 0x00000001<<j)
				sumNumber++;
		}
	}
	return sumNumber;
}

int main()
{
	char phones[][9]={
			"00000001",
			"00000006",
			"33000001",
			"00000101",
			"00000001"

	};
	for(int i=0;i<5;i++)
		cout<<phones[i]<<endl;
	cout<<StatisticalPhoneNumber(phones,5)<<endl;
	return 0;
}

题目2

对不重复的正整数进行排序，数据量很大

使用bitmap解决

代码如下：

#include<iostream>
#include<memory.h>

using namespace std;
//使用BitMap进行对数字进行标记，一个int占4个字节，即32位，因此，对于32以内的数可以表示，
//在这里，使用32位为一段，即该段最多表示32个标记，假设要排序的数不重复，且范围是0-1000


int const range = sizeof(int) * 8;
int const N = (1000 / range) + 1;
int BitMap2[N+1];

void SetBit(int number)
{//将number对应的为置1
	int position = number / range;
	int shifting = number % range;
	BitMap2[position] |= 0x00000001<<shifting;
}

void BitMapSort(int arr[], int n)
{
	memset(BitMap2,0,N*sizeof(int));
	for(int i=0;i<n;i++)
	{
		SetBit(arr[i]);
	}
	
	for(int i=0;i<N;i++)
	{
		for(int j=0;j<range;j++)//每次处理32位，一个int长度
		{
			if((BitMap2[i] & 0x00000001<<j) == 0x00000001<<j)//如果BitMap[i]的第j位为1，则输出该值
			{
				cout<<i*range+j<<"	";
			}
		}
	}
	cout<<endl;
}

int main()
{
	int arr[]={3,2,44,21,122,4};
	int length = sizeof(arr)/sizeof(int);
	BitMapSort(arr,length);
	return 0;
}

总结：

Bitmap擅长对应于寻找

某个数据是否在集合中出现过的问题

那几个数据出现在某个集合而没有出现在另一个集合的问题

难点：

映射函数很难搞，类似于上面这种超级简单的映射函数的情况可不是很多。

因此：

bitmap最好用来处理那些数据具有一定规律的（例如电话号码每次都可以移位，再比如IP地址也是可以这样映射）海量数据。杂乱无章不容易一眼看出规律的数据不太适合bitmap

问题实例

1、在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数

解法一：采用2-Bitmap（每个数分配2bit，00表示不存在，01表示出现一次，10表示多次，11无意义）进行，共需内存2^32 * 2 bit=1 GB内存，还可以接受。然后扫描这2.5亿个整数，查看Bitmap中相对应位，如果是00变01，01变10，10保持不变。所描完事后，查看bitmap，把对应位是01的整数输出即可。

解法二：也可采用与第1题类似的方法，进行划分小文件的方法。然后在小文件中找出不重复的整数，并排序。然后再进行归并，注意去除重复的元素。”

2、给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？

解法一：可以用位图/Bitmap的方法，申请512M的内存，一个bit位代表一个unsigned int值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。