一、定義
       點陣圖法就是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 ）
比如寫 1234 ，位元組序： 1234/8 = 154; 位序： 1234 &0b111 = 2（等價於：1234%8=2.思考下，為什麼要這樣取餘？) ，那麼 1234 放在 bit 的下標 154 位元組處，把該位元組的 2 號位（ 0~7）置為 1

位元組位置： int nBytePos =1234/8 = 154;

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

[cpp] 
// 把陣列的 154 位元組的 2 位置為 1  
unsigned short val = 1<<nBitPos;
bit[nBytePos] = bit[nBytePos] |val;  // 寫入 1234 得到arrBit[154]=0b00000100 

 再比如寫入 1236 ，

位元組位置： int nBytePos =1236/8 = 154;

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

[cpp]

// / 把陣列的 154 位元組的 4 位置為 1
val = 1<<nBitPos;
arrBit[nBytePos] = arrBit[nBytePos] |val;  // 再寫入 1236 得到arrBit[154]=0b00010100函式實現：
[cpp]
#define SHIFT 5    
#define MAXLINE 32    
#define MASK 0x1F    
void setbit(int *bitmap, int i){   
    bitmap[i >> SHIFT] |= (1 << (i & MASK));   
}

2，讀指定位（判斷i是否在bitmap中）

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

四、點陣圖法的缺點
    可讀性差
           點陣圖儲存的元素個數雖然比一般做法多，但是儲存的元素大小受限於儲存空間的大小。點陣圖儲存性質：儲存的元素個數等於元素的最大值。比如， 1K 位元組記憶體，能儲存 8K 個值大小上限為 8K 的元素。（元素值上限為 8K ，這個侷限性很大！）比如，要儲存值為 65535 的數，就必須要 65535/8=8K 位元組的記憶體。要就導致了點陣圖法根本不適合存 unsigned int 型別的數（大約需要 2^32/8=5 億位元組的記憶體）。
           點陣圖對有符號型別資料的儲存，需要 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了。

[cpp] 
#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; 
 
//  w397090770    
//  [email protected]    
//  2012.11.29  
 
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; 
}