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

最新推荐文章于 2025-03-25 15:09:33 发布
最新推荐文章于 2025-03-25 15:09:33 发布
阅读量1.2w 收藏 17
点赞数 6
分类专栏： 算法 数据结构 文章标签： 海量数据 位图 bitmap
本文通过具体案例介绍了位图法的原理与应用，包括位图的定义、数据结构、相关操作及其优缺点，并展示了如何使用位图法解决实际问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、定义

       位图法就是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;

<span style="color:#330033;">// 把数组的 154 字节的 2 位置为 1  
unsigned short val = 1<<nBitPos;  

bit[nBytePos] = bit[nBytePos] |val;  // 写入 1234 得到arrBit[154]=0b00000100  </span>

再比如写入 1236 ，

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

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

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

函数实现：
 

<span style="color:#330033;">#define SHIFT 5    
#define MAXLINE 32    
#define MASK 0x1F    
void setbit(int *bitmap, int i){    
    bitmap[i >> SHIFT] |= (1 << (i & MASK));    
}  </span>

2，读指定位

<span style="color:#330033;">bool getbit(int *bitmap1, int i){    
    return bitmap1[i >> SHIFT] & (1 << (i & MASK));    
}   </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.代码具有高度可重用性及可扩展性，以后将要在该作业基础上更改需求。

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

<span style="color:#330033;">#include<iostream>  
#include<vector>  
#include<cstdlib>  
#include<algorithm>  
#include<fstream>  
  
using namespace std;  
  
void merge(const vector<int> &, const vector<int>&, vector<int> &);  
  
int main(){  
    vector<int> v1, v2;  
    vector<int> result;  
    char buf[512];  
    FILE *fp;  
    fp = fopen("file1", "r");  
      
    if(fp < 0){  
        cout<<"Open file failed!\n";  
        exit(1);  
    }  
  
    while(fgets(buf, 512, fp) != NULL){  
        v1.push_back(atoi(buf));  
    }  
    sort(v1.begin(), v1.end());  
    fclose(fp);  
  
  
    fp = fopen("file2", "r");  
    if(fp < 0){  
        cout<<"Open file2 failed!\n";  
        exit(1);  
    }  
  
    while(fgets(buf, 512, fp) != NULL){  
        v2.push_back(atoi(buf));  
    }  
    sort(v2.begin(), v2.end());  
    cout<<v1[v1.size() - 1]<<endl;  
    cout<<v2[v2.size() - 1]<<endl;  
    fclose(fp);  
    merge(v1, v2, result);  
    cout<<result.size();  
      
    ofstream output;  
    output.open("result");  
    if(output.fail()){  
        cerr<<"crete file failed!\n";  
        exit(1);  
    }  
      
    vector<int>::const_iterator p = result.begin();  
    for(; p != result.end(); p++){  
        output<<*p<<endl;  
    }  
    output.close();  
    return 0;  
}  
  
void merge(const vector<int>& v1, const vector<int>& v2, vector<int> &result){  
    vector<int>::const_iterator p1, p2;  
    p1 = v1.begin();  
    p2 = v2.begin();  
      
    while((p1 != v1.end()) && p2 != v2.end()){  
        if(*p1 < *p2){  
            p1++;  
        }else if(*p1 > *p2){  
            p2++;  
        }else{  
            result.push_back(*p1);  
            p1++;  
            p2++;  
        }  
    }  
  
}  </span>

编译运行。

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

<span style="color:#330033;">#include <iostream>  
#include <fstream>  
#include <vector>  
#include <cstdlib>  
#include <cstdio>  
  
#define MAXLINE 32  
  
using namespace std;  
  
void qsort(vector<int>&, int, int);  
int partition(vector<int>&, int, int);  
bool binarySearch(const vector<int>&, int);  
  
int main(){  
    vector<int> v1, result;  
    int temp;  
    char buf[MAXLINE];  
    FILE *fd;  
  
    fd = fopen("file1", "r");  
    if(fd == NULL){  
        cerr<<"Open file1 failed!\n";  
        exit(1);  
    }  
    while(fgets(buf, MAXLINE, fd) != NULL){  
        v1.push_back(atoi(buf));  
    }  
      
    fclose(fd);  
    //cout<<v1.size()<<endl;  
    qsort(v1, 0, v1.size() - 1);  
      
    /*vector<int>::const_iterator p = v1.begin(); 
    for(; p != v1.end(); p++){ 
        cout<<*p<<endl; 
        sleep(1); 
    }*/  
  
    fd = fopen("file2", "r");  
    if(fd == NULL){  
        cerr<<"open file2 failed!\n";  
        exit(1);  
    }  
  
    while(fgets(buf, MAXLINE, fd) != NULL){  
        temp = atoi(buf);  
        if(binarySearch(v1, temp)){  
            result.push_back(temp);  
        }  
    }  
    cout<<result.size();  
  
    return 0;  
}  
  
void qsort(vector<int> &v, int low, int hight){  
    if(low < hight){  
        int mid = partition(v, low, hight);  
        qsort(v, low, mid - 1);  
        qsort(v, mid + 1, hight);  
    }  
}  
  
int  partition(vector<int> &v, int min, int max){  
    int temp = v[min];  
    while(min < max){  
        while(min < max && v[max] >= temp)  
            max--;  
        v[min] = v[max];  
        while(min < max && v[min] <= temp)  
            min++;  
        v[max] = v[min];  
    }  
  
    v[min] = temp;  
    return min;  
}  
  
bool binarySearch(const vector<int> &v, int key){  
    int low, hight, mid;  
    low = 0;   
    hight = v.size() - 1;  
      
    while(low <= hight){  
        mid = (low + hight) /2;  
        if(v[mid] == key){  
            return true;  
        }else if(v[mid] < key){  
            low = mid + 1;  
        }else{  
            hight = mid - 1;  
        }  
    }  
  
    return false;  
}  </span>

正乐着呢，编译运行：


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

<span style="color:#330033;">#include <iostream>  
#include <cstdlib>  
#include <cstdio>  
#include <cstring>  
#include <fstream>  
#include <string>  
#include <vector>  
#include <algorithm>  
#include <iterator>  
  
#define SHIFT 5  
#define MAXLINE 32  
#define MASK 0x1F  
  
using namespace std;  
  
void setbit(int *bitmap, int i){  
    bitmap[i >> SHIFT] |= (1 << (i & MASK));  
}  
  
bool getbit(int *bitmap1, int i){  
    return bitmap1[i >> SHIFT] & (1 << (i & MASK));  
}  
  
size_t getFileSize(ifstream &in, size_t &size){  
    in.seekg(0, ios::end);  
    size = in.tellg();  
    in.seekg(0, ios::beg);  
    return size;  
}  
  
char * fillBuf(const char *filename){  
    size_t size = 0;  
    ifstream in(filename);  
    if(in.fail()){  
        cerr<< "open " << filename << " failed!" << endl;  
        exit(1);  
    }  
    getFileSize(in, size);    
      
    char *buf = (char *)malloc(sizeof(char) * size + 1);  
    if(buf == NULL){  
        cerr << "malloc buf error!" << endl;  
        exit(1);  
    }  
      
    in.read(buf, size);  
    in.close();  
    buf[size] = '\0';  
    return buf;  
}  
void setBitMask(const char *filename, int *bit){  
    char *buf, *temp;  
    temp = buf = fillBuf(filename);  
    char *p = new char[11];  
    int len = 0;  
    while(*temp){  
        if(*temp == '\n'){  
            p[len] = '\0';  
            len = 0;  
            //cout<<p<<endl;  
            setbit(bit, atoi(p));  
        }else{  
            p[len++] = *temp;  
        }  
        temp++;  
    }  
    delete buf;  
}  
  
void compareBit(const char *filename, int *bit, vector<int> &result){  
    char *buf, *temp;  
    temp = buf = fillBuf(filename);  
    char *p = new char[11];  
    int len = 0;  
    while(*temp){  
        if(*temp == '\n'){  
            p[len] = '\0';  
            len = 0;  
            if(getbit(bit, atoi(p))){  
                result.push_back(atoi(p));  
            }  
        }else{  
            p[len++] = *temp;  
        }  
        temp++;  
    }  
    delete buf;  
}  
  
int main(){  
    vector<int> result;  
    unsigned int MAX = (unsigned int)(1 << 31);  
    unsigned int size = MAX >> 5;  
    int *bit1;  
  
    bit1 = (int *)malloc(sizeof(int) * (size + 1));  
    if(bit1 == NULL){  
        cerr<<"Malloc bit1 error!"<<endl;  
        exit(1);  
    }  
  
    memset(bit1, 0, size + 1);  
    setBitMask("file1", bit1);  
    compareBit("file2", bit1, result);  
    delete bit1;  
      
    cout<<result.size();  
    sort(result.begin(), result.end());  
    vector< int >::iterator   it = unique(result.begin(), result.end());  
  
    ofstream    of("result");  
    ostream_iterator<int> output(of, "\n");  
    copy(result.begin(), it, output);  
      
    return 0;  
}  </span>

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


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

C++海量数据处理——topk和查重问题分析
weixin_43825537的博客
06-10 1356
b
位图的简单实现（bitMap）
MaHua的博客
08-23 1726
一、位图的基本概念位图法（bitmap） 作用： 判断某个数据存在不存在 适用范围：大规模数据，数据状态又不多 什么是位图: http://baike.sogou.com/v72576997.htm?fromTitle=位图法所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。 例如，
位图法
why is this
02-12 869
定义        位图法就是bitmap的缩写。所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。在STL中有一个bitset容器，其实就是位图法，引用bitset介绍： A bitset is a special container class that is designed to store bits (ele
位图文件的保存
最新发布
可为测控的机器视觉专栏
03-25 320
其中，depth是像素深度也就是每个像素所占用的字节数(24位是3，32位为4)。了解位图的存储格式后，将位图保存到磁盘还是挺简单的，这里是基于Windows SDK的实现，有机会要自己定义各部分的结构体，实现位图文件的读写。2. bfSize，文件的大小，也就是文件头信息、位图头信息和位图数据在一起的大小。1. byType，文件类型，必须为0x4D42(BM)，表示是位图文件。3. bfOffBits，偏移量，位图数据相对于文件头的便宜量。填充后各部分信息后，依次写入到磁盘即可。
位图法：bitmap
jiechuhoudeshang的博客
05-09 515
文章目录 一、定义 二、数据结构 三、相关操作 四、位图法的缺点 五、位图法的应用 六、实现 一、定义 位图法就是bitmap的缩写。所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。在STL中有一个bitset容器，其实就是位图法，引用bitset介绍： Abitset is...
位图法bitmap
java_t_t的博客
06-14 538
概述：位图法bitmap 位图法是用一个bit的0/1代表这个bit所在位置的值存在与否 注：为什么不用boolean数组？ 根据《Java虚拟机规范》一书中的描述：“虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean...
海量数据处理——十道海量数据处理面试题与十个方法大总结
qxc10086的博客
08-23 499
第一部分、十道海量数据处理面试题 　　1、海量日志数据，提取出某日访问百度次数最多的那个IP。 　　此题，在我之前的一篇文章算法里头有所提到，当时给出的方案是：IP的数目还是有限的，最多2^32个，所以可以考虑使用hash将ip直接存入内存，然后进行统计。 　　再详细介绍下此方案：首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个
哈希的拓展——位图
宇哲
11-08 1849
关于哈希表，我们需要拓展一些知识，在这有一个位图需要我们理解。首先我们来看一道腾讯的题。 给4 0 亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这4 0 亿个数中。这道题我们怎么做呢？这是一道关于海量数据查找的题，其实这道题，我们就可以和哈希表联系在一起，为何说是海量数据呢，对于一个40亿整数，我们如果要存的话，按照无符号整数来存储，那么下来，大概就需要40亿*4这
操作系统常见面试问题和解析
zhangBurce的博客
08-10 525
操作系统常见面试问题1. 进程与线程的区别和联系2. 一个进程可以创建多少线程，和什么有关3. 一个程序从开始运行到结束的完整过程（四个过程）4. 进程通信方法（Linux和windows下），线程通信方法（Linux和windows下）5.文件读写使用的系统调用6. 怎么回收线程7. 守护进程、僵尸进程和孤儿进程8. 处理僵尸进程的两种经典方法9. 进程终止的几种方式10. linux中异常和中断的区别11. 一般情况下在Linux/windows平台下栈空间的大小12. 五种IO模型13. 守护进程14
海量数据去重排序bitmap(位图法)在java中实现的两种方法
08-26
今天小编就为大家分享一篇关于海量数据去重排序bitmap(位图法)在java中实现的两种方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
bitmap，位图法思路
yiyan12的专栏
04-07 450
bitmap适合做大量非重复整数的排序。 当然，在现实中，大量非重复整数排序的场景很少。 抽象来看，bitmap的思路是数据压缩。 比如说，1-100不重复的整数，用int表示，java中每个int需要32位，总共需要3200位的空间，使用位图法，只需要100位，每个数字对应其中一位。真实数据变成了数组索引，bitmap存的是是否存在的标志位。  ...
海量数据常用技巧之位图法
冬木
05-03 1935
介绍 位图的基本概念是用一个位（bit）来标记某个数据的存放状态，一个bit只能表示两种状态，所以不适合用来表示多状态（缺点1）。如果要表示多状态，需要用多个bit，但此时位图的性能会大打折扣，复杂度却增加了。由于采用了位为单位来存放数据，所以节省了大量的空间。一般把这种方法称为位图法，即Bitmap。 BitSet 正因为位图运算在空间方面（指的是海量数据的存储）的优越性，很多语言都有直接对
数据结构：位图法
runfeel
11-29 924
已移到：http://www.wypblog.com/archives/148一、定义 位图法就是bitmap的缩写。所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。在STL中有一个bitset容器，其实就是位图法，引用bitset介绍： A bitset is a special container class...
php 图片 位图,php实现位图法，处理海量数据
weixin_42528902的博客
04-09 243
100亿整型数据去重？整型数据为32位最多有2^32(42亿多)，所以100亿整型数据一定有重复的，2^32个整形用位表示，需要(2^32)bit==512MB,需要512MB内存表示。1.前言一般情况下，一个字符所占内存大小。UTF-8编码：一个英文字符等于一个字节，一个中文(含繁体)等于三个字节。我们知道一个1G=1024M，1M=1024K，1K=1024byte，1byte=8bit，所以...
大数据位图法（无重复排序，重复排序，去重复排序，数据压缩）之Java实现
LZW760907的博客
10-14 444
1，位图法介绍 位图的基本概念是用一个位（bit）来标记某个数据的存放状态，由于采用了位为单位来存放数据，所以节省了大量的空间。举个具体的例子，在Java中一般一个int数字要占用32位，如果能用一位就表示这个数，就可以缩减大量的存储空间。一般把这种方法称为位图法，即Bitmap。 位图法比较适合于判断是否存在这样的问题，元素的状态比较少，元素的个数比较多的情况之下。...
全局阈值分割——直方图法
05-23
全局阈值分割是一种简单有效的图像分割方法，直方图法是其中一种常用的实现方式。直方图是图像中像素灰度级的统计分布，直方图法通过分析图像的灰度直方图，找到一个合适的全局阈值，将图像分成两部分：前景和背景。 具体实现步骤如下： 1. 统计图像的灰度直方图； 2. 找到直方图中的峰值点，即灰度级最多的像素值； 3. 将峰值点作为全局阈值，将图像分成前景和背景两部分。 需要注意的是，这种方法对于光照不均匀、噪声较多等复杂情况的图像分割效果可能不理想，需要结合其他方法进行优化。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值