2. 程式人生 > >海量資料處理——點陣圖法bitmap

海量資料處理——點陣圖法bitmap

阿新 • • 發佈：2018-12-31
定義一個數組： 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>

這是利用點陣圖法實現的程式，編譯執行


執行時間明顯比前兩個少，但是這個程式是以空間換取時間，程式執行的時候分配了幾百兆的空間。可見在程式設計中，方法很重要。什麼情況選用什麼方法。但是還是覺得前面兩個方法還行，因為需要的空間比較少。

相關推薦

海量資料處理——點陣圖法bitmap

定義一個數組： unsigned char bit[8 * 1024];這樣做，能存 8K*8=64K 個 unsigned short 資料。bit 存放的位元組位置和位位置（位元組 0~8191 ，位 0~7 ） 比如寫 1234 ，位元組序： 1234/8 = 154; 位序： 1234 &a

[整理]資料結構----點陣圖法

一、定義        點陣圖法就是bitmap的縮寫。所謂bitmap，就是用每一位來存放某種狀態，適用於大規模資料，但資料狀態又不是很多的情況。通常是用來判斷某個資料存不存在的。在STL中有一個bitset容器，其實就是點陣圖法。 二、資料結構 unsigned int

【演算法-點陣圖法】在海量資料中查詢重複元素

什麼是點陣圖法？ 舉個簡單例子，在java中一個int型別的數有32位，而這32只表示一個數太過浪費，於是就考慮讓這32位可以表示32個數，每一位表示該數是否存在，例如： 這裡用16位的二進位制就能表示十六個數字，1表示存在，0表示不存在，上圖就表示存在（16，12，

[算法系列之十八]海量資料處理之BitMap

一：簡介 所謂的BitMap就是用一個bit位來標記某個元素對應的Value， 而Key即是該元素。由於採用了bit為單位來儲存資料，因此在儲存空間方面，可以大大節省。 二：基本思想 我們用一個具體的例子來講解，假設我們要對0-7內的5個元素(4,7,2,5,3)排

點陣圖&布隆過濾器&雜湊表的應用——海量資料處理

1. 給定一個大小超過 100G 的檔案, 其中存著 IP 地址, 找到其中出現次數最多的 IP 地址 100G遠遠大於記憶體的大小，因此不能一次全部讀入到記憶體中進行統計。 進行雜湊切分，一般的記憶體是4G，但肯定不能一下子把4G填滿，記憶體還要放其他的東

雜湊擴充套件【點陣圖，布隆】，海量資料處理

點陣圖： 它是用一個bit位來標識一個整數存在或者不存在，一般用於大資料的簡單確認是否存在 類似於雜湊的直接定址法，只不過點陣圖定在了一個位上，用bit上的0和1來標識一個數字存在或者不存在哈哈 typedef struct BitMap {

資料結構：點陣圖法（bitmap||BMP）

一、定義        點陣圖法就是bitmap的縮寫。所謂bitmap，就是用每一位來存放某種狀態，適用於大規模資料，但資料狀態又不是很多的情況。通常是用來判斷某個資料存不存在的。在STL中有一個bitset容器，引用bitset介紹： A bitset is a spe

由散列表到BitMap的概念與應用（三）：面試中的海量資料處理

一道面試題 在面試軟體開發工程師時，經常會遇到海量資料排序和去重的面試題，特別是大資料崗位。 例1：給定a、b兩個檔案，各存放50億個url，每個url各佔64位元組，記憶體限制是4G，找出a、b檔案共同的url? 首先我們最常想到的方法是讀取檔案a，建立雜湊表，然後再讀取檔案b，遍歷檔

Linux 核心資料結構：點陣圖（Bitmap）

https://github.com/0xAX/linux-insides/blob/master/DataStructures/bitmap.md Data Structures in the Linux Kernel Bit arrays and bit op

海量資料處理-----bitmap

【什麼是Bit-map】 所謂的Bit-map就是用一個bit位來標記某個元素對應的Value， 而Key即是該元素。由於採用了Bit為單位來儲存資料，因此在儲存空間方面，可以大大節省。 如果說了這麼多還沒明白什麼是Bit-map，那麼我們來看一個具體的例子，假設我們

資料結構之點陣圖（bitmap）詳解 （轉）

1.  概述 點陣圖（bitmap）是一種非常常用的結構，在索引，資料壓縮等方面有廣泛應用。本文介紹了點陣圖的實現方法及其應用場景。 2. 點陣圖實現 （1）自己實現 在點陣圖中，每個元素為“0”或“1”，表示其對應的元素不存在或者存在。 複製程式碼程式碼如

Bitmap和2-Bitmap海量資料處理問題

內容會持續更新，有錯誤的地方歡迎指正，謝謝! 題目 題1：在2.5億個整數找出不重複的整數，記憶體不足以容納著2.5億個整數。 題2：給40億個不重複的unsigned int的整數，沒排過序的，然後再給一個數，如何快速判斷這個數是否在那40億個數當中

十道海量資料處理面試題與十個方法大總結：

轉載之處：http://blog.csdn.net/liuqiyao_01/article/details/26567237 筆試 = （資料結構+演算法） 50%+ （計算機網路 + 作業系統）30% +邏輯智力題10%  + 資料庫5% + 歪門邪道題5%，而面

海量資料處理方法及應用

一、雜湊切割top K問題 1. 給一個超過100G大小的log file, log中存著IP地址, 設計演算法找到出現次數最多的IP地址？ （1）首先使用雜湊函式HashFunc(ip)將每一個IP地址轉化為整型，再通過HashFunc(i

海量資料處理例項

在bat等大公司，基本所有業務的資料量級都很龐大，那麼如何在保證資料完整性的情況下快速處理成了一個通用的難題，這裡列舉幾個例子，大致反應一些處理思想。 1.一個檔案中，每一行有一個整數，有上億行，目的：統計出現次數超過三次的整數寫入到另一個檔案中。 分析： （1）首先資料

海量資料處理演算法—Bit-Map

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Redis資料結構:點陣圖

原文：https://scalegrid.io/blog/introduction-to-redis-data-structure-bitmaps/ 點陣圖（也稱為位陣列，位向量等）是緊湊儲存位的陣列資料結構。它可以用來實現一個簡單的集資料結構。位陣列可以有效地利用硬體中的位級並行性來快速執行操

海量資料處理(一) 求top k問題

優先順序佇列 給一組海量資料，限制記憶體為2M，，找出裡面最大/小的Tokp k   int main() { vector<int> vec; srand(time(NULL)); for(int i =0;i<1000000;i++) { v

海量資料處理：十道面試題與十個海量資料處理方法總結（大資料演算法面試題）

第一部分、十道海量資料處理面試題 1、海量日誌資料，提取出某日訪問百度次數最多的那個IP。       首先是這一天，並且是訪問百度的日誌中的IP取出來，逐個寫入到一個大檔案中。注意到IP是32位的，最多有個2^32個IP。同樣可以採用對映的方法

海量資料處理問題

雜湊切割、Top K問題 問題一：給一個超過100G大小的log file, log中存著IP地址, 設計演算法找到出現次數最多的IP地址？ 問題二：與上題目條件相同，如何找出Top K的IP？ 問題