位图数据结构的

一、定义

       位图法就是bitmap的缩写。所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。在STL中有一个bitset容器，其实就是位图法，引用bitset介绍：

A bitset is a special container class that is designed to store bits (elements with only two possible values: 0 or 1, true or false, ...).The class is very similar to a regular array, but optimizing for space allocation: each element occupies only one bit (which is eight times less than the smallest elemental type in C++: char).Each element (each bit) can be accessed individually: for example, for a given bitset named mybitset, the expression mybitset[3] accesses its fourth bit, just like a regular array accesses its elements.

二、数据结构

unsigned int bit[N];

在这个数组里面，可以存储 N * sizeof(int)个数据，但是最大的数只能是N * sizeof(int) - 1。假如，我们要存储的数据范围为0-15，则我们只需要使得N=1，这样就可以把数据存进去。如下图：

数据为【5，1，7，15，0，4，6，10】，则存入这个结构中的情况为

三、相关操作

1，写入数据

定义一个数组： unsigned char bit[8 * 1024]; 这样做，能存 8K*8=64K 个 unsigned short 数据。 bit 存放的字节位置和位位置（字节 0~8191 ，位 0~7 ）（一个字节等于8位，位实际就是bit。char类型是一个字节，故是8 * 1024byte=8k，而因为存放位位置先是除以了8，故可以表示64k）

比如写 1234 ，字节序： 1234/8 = 154; 位序： 1234 &0b111 = 2 ，那么 1234 放在 bit 的下标 154 字节处，把该字节的 2 号位（ 0~7）置为 1

字节位置： int nBytePos =1234/8 = 154;

位位置：   int nBitPos = 1234 %7 = 2; 也可以1234&7=2得到位位置

[cpp]  view plain copy

1. // 把数组的 154 字节的 2 位置为 1  
2. unsigned short val = 1<<nBitPos;  
3. bit[nBytePos] = bit[nBytePos] |val;  // 写入 1234 得到arrBit[154]=0b0000010。这里是或操作与val或  

  再比如写入 1236 ，

字节位置： int nBytePos =1236/8 = 154;

位位置：   int nBitPos = 1236 & 7 = 4

[cpp]  view plain copy

1. // / 把数组的 154 字节的 4 位置为 1  
2. val = 1<<nBitPos;  
3. arrBit[nBytePos] = arrBit[nBytePos] |val;  // 再写入 1236 得到arrBit[154]=0b00000100  

函数实现：

[cpp]  view plain copy

1. #define SHIFT 5    
2. #define MAXLINE 32    
3. #define MASK 0x1F    
4. void setbit(int *bitmap, int i){    
5.     bitmap[i >> SHIFT] |= (1 << (i & MASK));    
6. }  

2，读指定位

[cpp]  view plain copy

1. bool getbit(int *bitmap1, int i){    
2.     return bitmap1[i >> SHIFT] & (1 << (i & MASK));    
3. }   

四、位图法的缺点

1. 可读性差
2. 位图存储的元素个数虽然比一般做法多，但是存储的元素大小受限于存储空间的大小。位图存储性质：存储的元素个数等于元素的最大值。比如， 1K 字节内存，能存储 8K 个值大小上限为 8K 的元素。（元素值上限为 8K ，这个局限性很大！）比如，要存储值为 65535 的数，就必须要 65535/8=8K 字节的内存。要就导致了位图法根本不适合存 unsigned int 类型的数（大约需要 2^32/8=5 亿字节的内存）。
3. 位图对有符号类型数据的存储，需要 2 位来表示一个有符号元素。这会让位图能存储的元素个数，元素值大小上限减半。 比如 8K 字节内存空间存储 short 类型数据只能存 8K*4=32K 个，元素值大小范围为 -32K~32K 。

五、位图法的应用

  1、给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中
　　首先，将这40亿个数字存储到bitmap中，然后对于给出的数，判断是否在bitmap中即可。
2、使用位图法判断整形数组是否存在重复
      遍历数组，一个一个放入bitmap，并且检查其是否在bitmap中出现过，如果没出现放入，否则即为重复的元素。
       3、使用位图法进行整形数组排序
      首先遍历数组，得到数组的最大最小值，然后根据这个最大最小值来缩小bitmap的范围。这里需要注意对于int的负数，都要转化为unsigned int来处理，而且取位的时候，数字要减去最小值。
       4、在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数
      参 考的一个方法是：采用2-Bitmap（每个数分配2bit，00表示不存在，01表示出现一次，10表示多次，11无意义）。其实，这里可以使用两个普 通的Bitmap，即第一个Bitmap存储的是整数是否出现，如果再次出现，则在第二个Bitmap中设置即可。这样的话，就可以使用简单的1- Bitmap了。

六、实现

要求在http://blog.csdn.net/w397090770/article/details/7388319里面

[cpp]  view plain copy

1. #include <iostream>  
2. #include <cstdlib>  
3. #include <cstdio>  
4. #include <cstring>  
5. #include <fstream>  
6. #include <string>  
7. #include <vector>  
8. #include <algorithm>  
9. #include <iterator>  
10.   
11. #define SHIFT 5  
12. #define MAXLINE 32  
13. #define MASK 0x1F  
14.   
15. using namespace std;  
16.   
17. //  w397090770    
18. //  wyphao.2007@163.com    
19. //  2012.11.29  
20.   
21. void setbit(int *bitmap, int i){  
22.     bitmap[i >> SHIFT] |= (1 << (i & MASK));  
23. }  
24.   
25. bool getbit(int *bitmap1, int i){  
26.     return bitmap1[i >> SHIFT] & (1 << (i & MASK));  
27. }  
28.   
29. size_t getFileSize(ifstream &in, size_t &size){  
30.     in.seekg(0, ios::end);  
31.     size = in.tellg();  
32.     in.seekg(0, ios::beg);  
33.     return size;  
34. }  
35.   
36. char * fillBuf(const char *filename){  
37.     size_t size = 0;  
38.     ifstream in(filename);  
39.     if(in.fail()){  
40.         cerr<< "open " << filename << " failed!" << endl;  
41.         exit(1);  
42.     }  
43.     getFileSize(in, size);    
44.       
45.     char *buf = (char *)malloc(sizeof(char) * size + 1);  
46.     if(buf == NULL){  
47.         cerr << "malloc buf error!" << endl;  
48.         exit(1);  
49.     }  
50.       
51.     in.read(buf, size);  
52.     in.close();  
53.     buf[size] = '\0';  
54.     return buf;  
55. }  
56. void setBitMask(const char *filename, int *bit){  
57.     char *buf, *temp;  
58.     temp = buf = fillBuf(filename);  
59.     char *p = new char[11];  
60.     int len = 0;  
61.     while(*temp){  
62.         if(*temp == '\n'){  
63.             p[len] = '\0';  
64.             len = 0;  
65.             //cout<<p<<endl;  
66.             setbit(bit, atoi(p));  
67.         }else{  
68.             p[len++] = *temp;  
69.         }  
70.         temp++;  
71.     }  
72.     delete buf;  
73. }  
74.   
75. void compareBit(const char *filename, int *bit, vector<int> &result){  
76.     char *buf, *temp;  
77.     temp = buf = fillBuf(filename);  
78.     char *p = new char[11];  
79.     int len = 0;  
80.     while(*temp){  
81.         if(*temp == '\n'){  
82.             p[len] = '\0';  
83.             len = 0;  
84.             if(getbit(bit, atoi(p))){  
85.                 result.push_back(atoi(p));  
86.             }  
87.         }else{  
88.             p[len++] = *temp;  
89.         }  
90.         temp++;  
91.     }  
92.     delete buf;  
93. }  
94.   
95. int main(){  
96.     vector<int> result;  
97.     unsigned int MAX = (unsigned int)(1 << 31);  
98.     unsigned int size = MAX >> 5;  
99.     int *bit1;  
100.   
101.     bit1 = (int *)malloc(sizeof(int) * (size + 1));  
102.     if(bit1 == NULL){  
103.         cerr<<"Malloc bit1 error!"<<endl;  
104.         exit(1);  
105.     }  
106.   
107.     memset(bit1, 0, size + 1);  
108.     setBitMask("file1", bit1);  
109.     compareBit("file2", bit1, result);  
110.     delete bit1;  
111.       
112.     cout<<result.size();  
113.     sort(result.begin(), result.end());  
114.     vector< int >::iterator   it = unique(result.begin(), result.end());  
115.   
116.     ofstream    of("result");  
117.     ostream_iterator<int> output(of, "\n");  
118.     copy(result.begin(), it, output);  
119.       
120.     return 0;  
121. }  

介绍

（20120511）位图就是通过将数组下标与应用中的一些值关联，数组中该下标所指定的位置上的元素可以用来标识应用中值的情况（是否存在 or 数目 or 。。。）。

 

位图中的值可以是计数、标识（如例1）。

可以运用在快速查找、排重、删除？、排序、压缩数据等。

实现

不同语言版本

相关应用

压缩

 

 

排序

 

例：有1000,0000个数，如果想对这些数排序，并且想尽量少用内存，该如何设计数据结构和排序算法？

方案1 ：采用32Bitmap（即容量为1000,1000/32，每个元素为32bit）位图中元素为整型32bit（下标为0-31），位图中元素可以存储相邻32个数是否存在的信息。例如89256 mod 32=2789…8，这样我们应该置a[2789]中32位字符串的第8位(从低位数起)为1。89257 mod 32=2789…9，设置a[2789]中元素的第9位为1。在将1000,0000个数都存入位图后，然后进行排序，遍历位图，将元素通过 ”位操作“还原为原值，输出。

 

注：来自http://blog.csdn.net/QIBAOYUAN/article/details/5914662 ，该文利用位图实现了压缩和排序，压缩体现在位图中每个元素为32位，将某个数与32取模，将取模后值对应到32位中的某位上设置为1，这样，32位就能保存相邻的32个数是否存在的信息。这样位图的大小就可以缩小到10000000/32.

 

 

搜索

 

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

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

 

例2：在Map3搜索例子中，通过将url的个数存储在bitmap中，可以通过歌曲id来快速找到歌曲url个数。

http://tech.techweb.com.cn/thread-222923-1-1.html

 

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

 

最简单的方法就是将这40亿个整数载入到数组中，然后遍历，看给定的数是否在这个数组中。但这是一个非常粗糙的方法，没有考虑存储空间和搜索效率问题。

 

可以考虑快速排序+二分查找，但是内存占用还是很大，并且如果40亿数据还有增加，涉及重排序。能不能有一种结构不用排序，占用内存比较少，面对增量数据也能从容应对呢？——bitmap

构建一个bitmap，元素为1bit（0表示无，1表示有），遍历40亿数据，设置bitmap里相应位置上元素值为1，搜索时只要根据目标值去bitmap里查找该位置上元素即可。

 

设计搜索剪枝时，需要保存已经搜索过的历史信息，有些情况下，可以使用位图减小历史信息数据所占空间。

 

扩展

 

Bloom filter

参考阅读

1. http://dongxicheng.org/structure/bitmap/ 

C++的STL中有bitmap类/

《编程珠玑》的第一章介绍了一种数据结构－位图。

该结构描述了一个有限定义域内的稠密集合，其中每一个元素最多出现一次并且没有其他任何数据与该元素相关联。

 

作者是通过一个实例来引出的这种数据结构，下面来看看这个实例。

1.问题描述

输入：一个最多包含n个正整数的文件，每个数都小于n，其中n=10的7次方。

输出：按升序排列的输入整数的列表。

约束：最多1MB的内存空间可用，有充足的磁盘空间可用。运行时间最多几分钟，运行时间为10秒就不需要进一步优化。

 

2.实现概要

作者由繁到简的介绍了各种方案，这里不一一列举了，我们重点关注一下最优的方法，即利用位图数据结构。

先用一个简单的例子来说明一下什么是位图表示集合。

例如：用如下字符串(0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0)来表示集合{1，2，3，5，8，13}。

代表集合中数值的位都置为1，其他所有的位都置0。

 

在我们的实际问题中，每个7位十进制整数表示一个小于1000万的整数。我们使用一个具有1000万个位的字符串来表示这个文件，其中，当且仅当整数i在文件中存在时，第i位为1。

这种表示利用了该问题的三个在排序问题中不常见的属性：输入数据限制在相对较小的范围内；数据没有重复；对每条记录而言，除了单一整数外，没有关联数据。

 

3.编写程序

在给定表示文件中整数集合的位图数据结构，可以分3个阶段来编写程序。

(1)将所有的位都置为0，初始化集合为空；

(2)通过读入文件中每个整数来建立集合，将每个对应的位置都置为1；

(3)检验每一位，如果该位为1，就输出对应的整数，由此产生有序的输出文件。

伪代码如下：

//phase 1:initialize set to empty

for i=[0, n]

　　　　bit[i] = 0

//phase 2:insert present elements into the set

for each i in the imput file

　　　　bit[i] = 1

//phase 3:write sorted output

for i = [0, n]

　　　　if bit[i] == 1

　　　　　　　　write i on the output file 此处巧妙的利用了值为1的位置的序号 = 要排序的数字

这种方式确实比单纯的利用排序算法来实现目标更高效和简单。