海量数据处理——位图法bitmap

海量数据处理——位图法bitmap

一、定义

       位图法就是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) * 8个数据,但是最大的数只能是N * sizeof(int)  * 8 - 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 )

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

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

位位置:   int nBitPos = 1234 & 7 = 2;

[cpp] view plain copy
  1. <span style="color:#330033;">// 把数组的 154 字节的 2 位置为 1    
  2. unsigned short val = 1<<nBitPos;    
  3.   
  4. bit[nBytePos] = bit[nBytePos] |val;  // 写入 1234 得到arrBit[154]=0b00000100  </span>  

再比如写入 1236 ,

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

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

[cpp] view plain copy
  1. <span style="color:#330033;">// / 把数组的 154 字节的 4 位置为 1    
  2. val = 1<<nBitPos;   
  3.    
  4. arrBit[nBytePos] = arrBit[nBytePos] |val;  // 再写入 1236 得到arrBit[154]=0b00010100  </span>  

函数实现:

[cpp] view plain copy
  1. <span style="color:#330033;">#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. }  </span>  

2,读指定位

[cpp] view plain copy
  1. <span style="color:#330033;">bool getbit(int *bitmap1, int i){      
  2.     return bitmap1[i >> SHIFT] & (1 << (i & MASK));      
  3. }   </span>  

四、位图法的缺点

  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了。

求解问题如下:

在本地磁盘里面有file1和file2两个文件,每一个文件包含500万条随机整数(可以重复),最大不超过2147483648也就是一个int表示范围。要求写程序将两个文件中都含有的整数输出到一个新文件中。

要求:
1.程序的运行时间不超过5秒钟。
2.没有内存泄漏。
3.代码规范,能要考虑到出错情况。

4.代码具有高度可重用性及可扩展性,以后将要在该作业基础上更改需求。

初一看,觉得很简单,不就是求两个文件的并集嘛,于是很快写出了下面的代码。

[cpp] view plain copy
  1. <span style="color:#330033;">#include<iostream>    
  2. #include<vector>    
  3. #include<cstdlib>    
  4. #include<algorithm>    
  5. #include<fstream>    
  6.     
  7. using namespace std;    
  8.     
  9. void merge(const vector<int> &, const vector<int>&, vector<int> &);    
  10.     
  11. int main(){    
  12.     vector<int> v1, v2;    
  13.     vector<int> result;    
  14.     char buf[512];    
  15.     FILE *fp;    
  16.     fp = fopen("file1""r");    
  17.         
  18.     if(fp < 0){    
  19.         cout<<"Open file failed!\n";    
  20.         exit(1);    
  21.     }    
  22.     
  23.     while(fgets(buf, 512, fp) != NULL){    
  24.         v1.push_back(atoi(buf));    
  25.     }    
  26.     sort(v1.begin(), v1.end());    
  27.     fclose(fp);    
  28.     
  29.     
  30.     fp = fopen("file2""r");    
  31.     if(fp < 0){    
  32.         cout<<"Open file2 failed!\n";    
  33.         exit(1);    
  34.     }    
  35.     
  36.     while(fgets(buf, 512, fp) != NULL){    
  37.         v2.push_back(atoi(buf));    
  38.     }    
  39.     sort(v2.begin(), v2.end());    
  40.     cout<<v1[v1.size() - 1]<<endl;    
  41.     cout<<v2[v2.size() - 1]<<endl;    
  42.     fclose(fp);    
  43.     merge(v1, v2, result);    
  44.     cout<<result.size();    
  45.         
  46.     ofstream output;    
  47.     output.open("result");    
  48.     if(output.fail()){    
  49.         cerr<<"crete file failed!\n";    
  50.         exit(1);    
  51.     }    
  52.         
  53.     vector<int>::const_iterator p = result.begin();    
  54.     for(; p != result.end(); p++){    
  55.         output<<*p<<endl;    
  56.     }    
  57.     output.close();    
  58.     return 0;    
  59. }    
  60.     
  61. void merge(const vector<int>& v1, const vector<int>& v2, vector<int> &result){    
  62.     vector<int>::const_iterator p1, p2;    
  63.     p1 = v1.begin();    
  64.     p2 = v2.begin();    
  65.         
  66.     while((p1 != v1.end()) && p2 != v2.end()){    
  67.         if(*p1 < *p2){    
  68.             p1++;    
  69.         }else if(*p1 > *p2){    
  70.             p2++;    
  71.         }else{    
  72.             result.push_back(*p1);    
  73.             p1++;    
  74.             p2++;    
  75.         }    
  76.     }    
  77.     
  78. }  </span>  

编译运行。

一看,不行,不满足上面的5秒之内,于是又想了很久,上面不是显示sys调用花了很长时间嘛,于是有写了一个程序,用快速排序+二分查找法实现,代码如下:

[cpp] view plain copy
  1. <span style="color:#330033;">#include <iostream>    
  2. #include <fstream>    
  3. #include <vector>    
  4. #include <cstdlib>    
  5. #include <cstdio>    
  6.     
  7. #define MAXLINE 32    
  8.     
  9. using namespace std;    
  10.     
  11. void qsort(vector<int>&, intint);    
  12. int partition(vector<int>&, intint);    
  13. bool binarySearch(const vector<int>&, int);    
  14.     
  15. int main(){    
  16.     vector<int> v1, result;    
  17.     int temp;    
  18.     char buf[MAXLINE];    
  19.     FILE *fd;    
  20.     
  21.     fd = fopen("file1""r");    
  22.     if(fd == NULL){    
  23.         cerr<<"Open file1 failed!\n";    
  24.         exit(1);    
  25.     }    
  26.     while(fgets(buf, MAXLINE, fd) != NULL){    
  27.         v1.push_back(atoi(buf));    
  28.     }    
  29.         
  30.     fclose(fd);    
  31.     //cout<<v1.size()<<endl;    
  32.     qsort(v1, 0, v1.size() - 1);    
  33.         
  34.     /*vector<int>::const_iterator p = v1.begin();  
  35.     for(; p != v1.end(); p++){  
  36.         cout<<*p<<endl;  
  37.         sleep(1);  
  38.     }*/    
  39.     
  40.     fd = fopen("file2""r");    
  41.     if(fd == NULL){    
  42.         cerr<<"open file2 failed!\n";    
  43.         exit(1);    
  44.     }    
  45.     
  46.     while(fgets(buf, MAXLINE, fd) != NULL){    
  47.         temp = atoi(buf);    
  48.         if(binarySearch(v1, temp)){    
  49.             result.push_back(temp);    
  50.         }    
  51.     }    
  52.     cout<<result.size();    
  53.     
  54.     return 0;    
  55. }    
  56.     
  57. void qsort(vector<int> &v, int low, int hight){    
  58.     if(low < hight){    
  59.         int mid = partition(v, low, hight);    
  60.         qsort(v, low, mid - 1);    
  61.         qsort(v, mid + 1, hight);    
  62.     }    
  63. }    
  64.     
  65. int  partition(vector<int> &v, int min, int max){    
  66.     int temp = v[min];    
  67.     while(min < max){    
  68.         while(min < max && v[max] >= temp)    
  69.             max--;    
  70.         v[min] = v[max];    
  71.         while(min < max && v[min] <= temp)    
  72.             min++;    
  73.         v[max] = v[min];    
  74.     }    
  75.     
  76.     v[min] = temp;    
  77.     return min;    
  78. }    
  79.     
  80. bool binarySearch(const vector<int> &v, int key){    
  81.     int low, hight, mid;    
  82.     low = 0;     
  83.     hight = v.size() - 1;    
  84.         
  85.     while(low <= hight){    
  86.         mid = (low + hight) /2;    
  87.         if(v[mid] == key){    
  88.             return true;    
  89.         }else if(v[mid] < key){    
  90.             low = mid + 1;    
  91.         }else{    
  92.             hight = mid - 1;    
  93.         }    
  94.     }    
  95.     
  96.     return false;    
  97. }  </span>  

正乐着呢,编译运行:


结果发现,user时间是2.194秒,整个时间还要比以前长,显然这种方法还是不行,原因就是两个文件太大了,500万条,不是一般小,且上面花的时间主要用在排序上面去了,于是就想,能不能不用排序完成?这时有个朋友和我说了一下位图法,灵感一来,自己又去改写了代码:

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

这是利用位图法实现的程序,编译运行


运行时间明显比前两个少,但是这个程序是以空间换取时间,程序运行的时候分配了几百兆的空间。可见在程序设计中,方法很重要。什么情况选用什么方法。但是还是觉得前面两个方法还行,因为需要的空间比较少。

展开阅读全文

没有更多推荐了,返回首页