在學習hashtable的時候，發現用於標記懶惰刪除的資料結果是Bitmap，詳見資料結果習題解析(c++語言)(第三版) 鄧俊輝編著。理論上來說，可以用一個數組或者是std::vector來進行標記，但是Bitmap則具有更高的空間效率和時間效率。下面主要參考該書，對Bitmap進行了學習。

1. 什麼是Bitmap

1Byte = 8 bit，而Bitmap的每個bit位對應0或者1，代表真或假，bitmap則是一系列0與1構成的集合。如果用bool陣列來代表Hashtable的懶惰刪除標記，bool佔一個位元組，有8bit，其所佔空間為Bitmap的8倍。另外，bitmap不僅僅是空間效率高，還可以在O(1)時間內，對其進行賦值和讀取。

2. Bitmap的c++實現

/// @file bitmap.hpp
/// @brief declaration and implementation of bitmap class 
/// @author Shengfa Zhu, [email protected]
/// @version 1.0
/// @date 2018-03-06

#include <memory.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>//header file of FILE, fopen, fread, fclose

class Bitmap {
private:
    char* M;//M[] is room for bitmap N * sizeof(char)*8 bit
    int N;

protected:
    void init(int n) {
        N = (n + 7) / 8;
        M = new char[N];
        memset(M, 0, N);
    }

public:
    
    /// @brief constructor
    Bitmap(int n = 8) {//creat bitmap with given size
        init(n);
    }

    /// @brief overide constructor 
    Bitmap(char* file, int n = 8) {//creat bitmap from file
        init(n);
        FILE* fp = fopen(file, "r");
        fread(M, sizeof(char), N, fp);
        fclose(fp);
    }

    /// @brief deconstructor
    ~Bitmap(){
        delete []M;
        M = NULL;
    }

    /// @brief set kth positon to 1
    void set(int k) {
        expand(k);
    //1 byte = 8 bit, 0x80=128, 0x07=7
    // a |= b :: a = a | b
        M[k >> 3] |= (0x80 >> (k & 0x07));//位操作
    }

    /// @brief clear kth positin of bitmap
    void clear(int k) {
        expand(k);
        M[k >> 3] &= ~(0x80 >> (k & 0x07));
    }

    /// @brief test ith is true or not
    bool test(int k) {
        expand(k);
        return M[k >> 3] & (0x80 >> (k & 0x07));
    }

    /// @brief expand room of M if k overflow
    void expand(int k) {
        if (k < 8 * N) return;
        int oldN = N;
        char* oldM = M;
        init(2 * k);//double size
        memcpy(M, oldM, oldN);//copy data to new M
        delete [] oldM;//release old room 
    }
    
    /// @brief convert n position to string
    char* bits2string(int n) {
        expand(n - 1);
        char* s = new char[n + 1];
        s[n] = '\0';
        for (int i = 0; i < n; i++) {
            s[i] = test(i) ? '1' : '0';
        }
        return s;
    }

    void dump(const char* file) {
        FILE* fp = fopen(file, "w");
        fwrite(M, sizeof(char), N, fp);
        fclose(fp);
    }
};
 

上述程式基本與資料結果習題解析(c++語言)(第三版) 鄧俊輝編著的P61-62相同。其中，以字元陣列來表示bitmap，在c++中char佔一個位元組，也就是8bit。在賦值的時候，由於無法對某個bit進行賦值操作，因此應用了位操作。

下面重點解釋下下面這行程式：

M[k >> 3] |= (0x80 >> (k & 0x07))

取k = 10 = 000001010（二進位制）為例，應當將第10個bit(0為起點)設為1，也就是第2個字元(以1為起點)中的第3個(以1為起點)，而其他位保持不變。

k>>3 : 表示右移三位 k >>3 = 00000001=1, 取陣列的第2個字元進行操作；

k & 0x07 : 0x07（16進位制）= 7（10進位制）= 00000111 （2進位制），k & 0x07 = 000000010 = 2,

0x80 >>(k & 0x07) : 0x80（16進位制）= 128（ 10進位制）= 10000000 （2進位制）, 0x80 >>(k & 0x07) = 00100000

再經過一個與位操作之後，就可以將對應位置上的數設為1，而不影響其他位置。

從上面程式可以看出，set() clear() test()均是常數時間複雜度，並且使用了更為高效的位操作，有較高的效率。

3. Eratothenes篩法求素數

bitmap有很多的應用，例如可以用來不重複資料的排序，下面介紹如何基於bitmap求素數。先簡要介紹下一種求素數的演算法Eratothenes篩法。

自然數分為素數和合數，所有素數的整數倍均是合數，Eratothenes（希臘先哲）篩法就是基於上述的思想。從2開始對自然數進行遍歷，將2的整數倍的數去掉，然後遍歷到3, 將3的整數倍篩掉，在遍歷到5(4已經被去掉了), 將5的整數倍去掉，從此往後，剩下的數均是素數。

4. 基於Bitmap類 Eratothenes篩法的實現

可以基於Bitmap方便地實現Eratothenes演算法求得不超過n的所有素數，首先0和1不是素數。從2開始遍歷到n,將素數的整數倍所對應的bit位置設為1。遍歷完成之後，所有bit位是0的數就是不超過n的所有素數。

void Eratothenes(const int& n) {
    Bitmap B(n);
    B.set(0);//0 is not prime number
    B.set(1);//1 is not prime number
    for(int i = 2; i < n; i++) {
        if(!B.test(i)) 
            for(int j = i * i; j < n; j += i)
                B.set(j);
    }
    //print to monitor
    for(int i = 2; i < n; i++) {
        if(!B.test(i))
            std::cout << i << "\t";
    }
    std::cout << std::endl;
}

以上內容，大都參考鄧俊輝老師編寫的教材，將其記錄下來方便自己自學