2. 程式人生 > >點陣圖和布隆過濾器

點陣圖和布隆過濾器

阿新 • • 發佈：2019-02-11

給四十億個不重複的無符號整數，再給你一個無符號整數，如何快速
判斷一個數是否在這四十億個數中？

1byte=8bit；
1kB=1024byte；
1MB=1024KB；
1GB=1024MB；

1GB大約有10億多個位元組，而40億個無符號整數有160億個位元組，所以要存放下40億
個無符號整數大約需要16GB空間，然而我們的電腦記憶體沒有這麼大，我們需要想一種方法
來解決這個問題？

對於這種問題我們可以使用點陣圖，我們沒有必要用四個位元組來存放一個數，因為我們
只用判斷一個數是否在這40億個數中，我們可以把一個數存放在一個位元位上，1表示
存在，0表示不存在，這樣這40億個數就需要大約500M空間，當要判斷的時候我們
可以算出這個數在bitmap中的下標，1表示存在，0表示不存在，這樣我們就完成這個問題了。

//點陣圖
//點陣圖
#pragma once
class BitMap
{
public:
    BitMap(size_t range)
    {
        _Bitmap.resize(range / 8+1, 0); //設定點陣圖大小
    }
    void Set(size_t value)//置1
    {
        size_t index = value >> 3;
        size_t pos = value % 8;
        _Bitmap[index] |= (1 << pos);
    }
    void Reset(size_t value) //置0
 

    {
        size_t index = value >> 3;
        size_t pos = value % 8;
        _Bitmap[index] &= (~(1 << pos));
    }
    bool Test(size_t value)
    {
        size_t index = value >> 3;
        size_t pos = value % 8;
        return _Bitmap[index] & (1 << pos);
    }
protected
 
:
    vector<char> _Bitmap;
};

void TestBitMap()
{
    BitMap bt(-1);
    bt.Set(1);
    bt.Set(12);
    bt.Set(123);
    bt.Set(1234);
    bt.Set(12345);
    cout << bt.Test(0) << endl;
    cout << bt.Test(1) << endl;
    cout << bt.Test(12) << endl;
    cout << bt.Test(123) << endl;
    cout << bt.Test(1234) << endl;
    cout << bt.Test(12345) << endl;
    cout << bt.Test(321) << endl;

    bt.Reset(1234);
    bt.Reset(12345);
    cout << endl;
    cout << bt.Test(0) << endl;
    cout << bt.Test(1) << endl;
    cout << bt.Test(12) << endl;
    cout << bt.Test(123) << endl;
    cout << bt.Test(1234) << endl;
    cout << bt.Test(12345) << endl;
    cout << bt.Test(321) << endl;

}

點陣圖只能用來快速判斷一個整數是否在一堆整數中，如果我們想要判斷一個字串
是否在一堆字串裡，那麼點陣圖就做不到了，因此布隆過濾器就出現了。

布隆過濾器：布隆過濾器其實是結合了點陣圖與雜湊表，先將字串用字串雜湊演算法
對映到雜湊表中，但是由於雜湊衝突，我們可以一個字串使用多個不同的字串雜湊
演算法同時對映在這個雜湊表中，判斷一個字串是否在這堆字串中，我們可以算出
這個字串的位置，當且僅當這個字串每個對映位置都是1才表示存在，只要有一個
位置為0，就表示不存在；

#pragma once
#include "BitMap.h"

struct __HashFunc1
{
    size_t BKDRHash(const char *str)//雜湊演算法
    {          //這裡的雜湊演算法都是取至連結當中
        register size_t hash = 0;
        while (size_t ch = (size_t)*str++)
        {
            hash = hash * 131 + ch;
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return BKDRHash(s.c_str());
    }
};
struct __HashFunc2
{
    size_t SDBMHash(const char *str)
    {
        register size_t hash = 0;
        while (size_t ch = (size_t)*str++)
        {
            hash = 65599 * hash + ch;

        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return SDBMHash(s.c_str());
    }
};
struct __HashFunc3
{
    size_t RSHash(const char *str)
    {
        register size_t hash = 0;
        size_t magic = 63689;
        while (size_t ch = (size_t)*str++)
        {
            hash = hash * magic + ch;
            magic *= 378551;
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return RSHash(s.c_str());
    }
};
struct __HashFunc4
{
    size_t APHash(const char *str)
    {
        register size_t hash = 0;
        size_t ch;
        for (long i = 0; ch = (size_t)*str++; i++)
        {
            if ((i & 1) == 0)
            {
                hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
            }
            else
            {
                hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
            }
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return  APHash(s.c_str());
    }
};
struct __HashFunc5
{
    size_t JSHash(const char *str)
    {
        if (!*str)        // 這是由本人新增，以保證空字串返回雜湊值0  
            return 0;
        register size_t hash = 1315423911;
        while (size_t ch = (size_t)*str++)
        {
            hash ^= ((hash << 5) + ch + (hash >> 2));
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return JSHash(s.c_str());
    }
};

template<class K=string
    ,class HashFunc1=__HashFunc1
    , class HashFunc2=__HashFunc2
    , class HashFunc3=__HashFunc3
    ,class HashFunc4=__HashFunc4
    ,class HashFunc5=__HashFunc5>
class BloomFilter
{
public:
    BloomFilter(size_t size)
        :_bitmap(size * 5) 
        , range(size * 5)
    {}
    void Setb(const K& key)
    {
        size_t hash1 = HashFunc1()(key) % range;
        size_t hash2 = HashFunc2()(key) % range;
        size_t hash3 = HashFunc3()(key) % range;
        size_t hash4 = HashFunc4()(key) % range;
        size_t hash5 = HashFunc5()(key) % range;
        //為了減少誤判，提高精度，一個數對映到5個位置
        _bitmap.Set(hash1);
        _bitmap.Set(hash2);
        _bitmap.Set(hash3);
        _bitmap.Set(hash4);
        _bitmap.Set(hash5);
    }
    bool Test(const K& key)
    {
        size_t hash1 = HashFunc1()(key) % range;
        size_t hash2 = HashFunc2()(key) % range;
        size_t hash3 = HashFunc3()(key) % range;
        size_t hash4 = HashFunc4()(key) % range;
        size_t hash5 = HashFunc5()(key) % range;
        if (_bitmap.Test(hash1) == false)
            return false;
        if (_bitmap.Test(hash2) == false)
            return false;
        if (_bitmap.Test(hash3) == false)
            return false;
        if (_bitmap.Test(hash4) == false)
            return false;
        if (_bitmap.Test(hash5) == false)
            return false;
        return true;
    }
protected:
    BitMap _bitmap;
    size_t range;
};

void TestBloomFilter()
{
    BloomFilter<> bf(1024);
    bf.Setb("abcd");
    bf.Setb("1234");
    bf.Setb("qwer");
    bf.Setb("zxcv");
    bf.Setb("mlop");
    cout << bf.Test("0123") << endl;
    cout << bf.Test("abcd") << endl;
    cout << bf.Test("1234") << endl;
    cout << bf.Test("zxcv") << endl;
    cout << bf.Test("mlop") << endl;
    cout << bf.Test("4569") << endl;
}

上邊這個布隆演算法節省空間但是不支援刪除演算法，因為上邊那個演算法有可能一個位置
映射了幾個數，刪除了一個數可能會影響到別的數；

如果我們想要使用刪除演算法，我們可以使用引用計數的方法，那麼存放一個數的位置
就不能用一個位元位了，而是可以用一個無符號整數來存放，當刪除一個數的時候，
如果它對映到的每個位置都大於0，就表明這個數存在，那麼就讓這幾個數同時減1；

因為這個演算法為了使用刪除演算法，浪費了一些空間，適用於少量的資料

#pragma once

struct __HashFunc1
{
    size_t BKDRHash(const char *str)
    {
        register size_t hash = 0;
        while (size_t ch = (size_t)*str++)
        {
            hash = hash * 131 + ch;
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return BKDRHash(s.c_str());
    }
};
struct __HashFunc2
{
    size_t SDBMHash(const char *str)
    {
        register size_t hash = 0;
        while (size_t ch = (size_t)*str++)
        {
            hash = 65599 * hash + ch;

        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return SDBMHash(s.c_str());
    }
};
struct __HashFunc3
{
    size_t RSHash(const char *str)
    {
        register size_t hash = 0;
        size_t magic = 63689;
        while (size_t ch = (size_t)*str++)
        {
            hash = hash * magic + ch;
            magic *= 378551;
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return RSHash(s.c_str());
    }
};
struct __HashFunc4
{
    size_t APHash(const char *str)
    {
        register size_t hash = 0;
        size_t ch;
        for (long i = 0; ch = (size_t)*str++; i++)
        {
            if ((i & 1) == 0)
            {
                hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
            }
            else
            {
                hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
            }
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return  APHash(s.c_str());
    }
};
struct __HashFunc5
{
    size_t JSHash(const char *str)
    {
        if (!*str)        // 這是由本人新增，以保證空字串返回雜湊值0  
            return 0;
        register size_t hash = 1315423911;
        while (size_t ch = (size_t)*str++)
        {
            hash ^= ((hash << 5) + ch + (hash >> 2));
        }
        return hash;
    }
    size_t operator()(const string& s)
    {
        return JSHash(s.c_str());
    }
};

template<class K = string
    , class HashFunc1 = __HashFunc1
    , class HashFunc2 = __HashFunc2
    , class HashFunc3 = __HashFunc3
    , class HashFunc4 = __HashFunc4
    , class HashFunc5 = __HashFunc5>
class BoolmFilter
{
public:
    BoolmFilter(size_t range)
    {
        _bitmap.resize(range * 5, 0);
    }
    void Setb(const K& value)
    {
        size_t range = _bitmap.size();
        size_t hash1 = HashFunc1()(value) % range;
        size_t hash2 = HashFunc2()(value) % range;
        size_t hash3 = HashFunc3()(value) % range;
        size_t hash4 = HashFunc4()(value) % range;
        size_t hash5 = HashFunc5()(value) % range;
        _bitmap[hash1]++;
        _bitmap[hash2]++;
        _bitmap[hash3]++;
        _bitmap[hash4]++;
        _bitmap[hash5]++;
    }
    bool Reset(const K& value)
    {
        size_t range = _bitmap.size();
        size_t hash1 = HashFunc1()(value) % range;
        size_t hash2 = HashFunc2()(value) % range;
        size_t hash3 = HashFunc3()(value) % range;
        size_t hash4 = HashFunc4()(value) % range;
        size_t hash5 = HashFunc5()(value) % range;
        if (_bitmap[hash1] == 0
            || _bitmap[hash2] == 0
            || _bitmap[hash3] == 0
            || _bitmap[hash4] == 0
            || _bitmap[hash5] == 0)
        {
            return false; //如果這幾個位置任意一個為0表示不存在不能刪除
        }
        _bitmap[hash1]--;
        _bitmap[hash2]--;
        _bitmap[hash3]--;
        _bitmap[hash4]--;
        _bitmap[hash5]--;
        return true;
    }
    bool Test(const K& value)
    {
        size_t range = _bitmap.size();
        size_t hash1 = HashFunc1()(value) % range;
        size_t hash2 = HashFunc2()(value) % range;
        size_t hash3 = HashFunc3()(value) % range;
        size_t hash4 = HashFunc4()(value) % range;
        size_t hash5 = HashFunc5()(value) % range;
        if (_bitmap[hash1] != 0
            && _bitmap[hash2] != 0
            && _bitmap[hash3] != 0
            && _bitmap[hash4] != 0
            && _bitmap[hash5] != 0)
        {
            return true;
        }
        return false;
    }
protected:
    vector<size_t> _bitmap;  //存放無符號整形
};

void TestBloomFilter()
{
    BoolmFilter<> bf(1024);
    bf.Setb("abcd");
    bf.Setb("1234");
    bf.Setb("qwer");
    bf.Setb("zxcv");
    bf.Setb("mlop");
    cout << bf.Test("0123") << endl;
    cout << bf.Test("abcd") << endl;
    cout << bf.Test("1234") << endl;
    cout << bf.Test("zxcv") << endl;
    cout << bf.Test("mlop") << endl;
    cout << bf.Test("4569") << endl;
    bf.Reset("zxcv");
    bf.Reset("mlop");
    cout << endl;
    cout << bf.Test("0123") << endl;
    cout << bf.Test("abcd") << endl;
    cout << bf.Test("1234") << endl;
    cout << bf.Test("zxcv") << endl;
    cout << bf.Test("mlop") << endl;
    cout << bf.Test("4569") << endl;
}

相關推薦

點陣圖和布隆過濾器

給四十億個不重複的無符號整數，再給你一個無符號整數，如何快速 判斷一個數是否在這四十億個數中？ 1byte=8bit； 1kB=1024byte； 1MB=1024KB； 1GB=1024MB； 1GB大約有10億多個位元組，而40億個無符號整數有1

大量資料去重：Bitmap點陣圖演算法和布隆過濾器(Bloom Filter)

Bitmap演算法 與其說是演算法，不如說是一種緊湊的資料儲存結構。是用記憶體中連續的二進位制位(bit)，用於對大量整型資料做去重和查詢。其實如果並非如此大量的資料，有很多排重方案可以使用，典型的就是雜湊表。 實際上，雜湊表為每一個可能出現的數字提供了一個一一對映的關係，每個元素都相當於有

【資料結構】點陣圖與布隆處理器

文章目錄 1.點陣圖的實現 BitMap.h BitMap.c 2.布隆的實現 BloomFilter.h BloomFilter.c 1.點陣圖

以太坊：事件、日誌和布隆過濾器

 版權宣告：本文系博主原創，未經博主許可，禁止轉載。保留所有權利。 引用網址：https://www.cnblogs.com/zhizaixingzou/p/10122288.html   目錄   1. 事件、日誌和布隆過濾器 本文Java原始碼截圖來

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

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

大量資料去重：Bitmap和布隆過濾器(Bloom Filter)

5TB的硬碟上放滿了資料，請寫一個演算法將這些資料進行排重。如果這些資料是一些32bit大小的資料該如何解決？如果是64bit的呢？在面試時遇到的問題，問題的解決方案十分典型，但對於海量資料處理接觸少的同學可能一時也想不到什麼好方案。介紹兩個演算法，對於空間的利用到達了一種極

利用記憶體資料庫和布隆過濾器寫的網路爬蟲

記憶體資料庫用來儲存待訪問url，布隆過濾器用來記錄已訪問的url。先前我們待訪問url是存放在記憶體中，已訪問的url是利用HashSet實現的。 布隆過濾器package hashfilter; import java.util.BitSet; import bdb

【資料結構】點陣圖BitMap與布隆過濾器BloomFilter

  首先先看一下下面這個騰訊的面試題：給40億個不重複的無符號整數，沒排過序。給一個無符號整數，如何快速判斷一個數是否在這40億個數中。 【騰訊】思路一：  最容易想到的解法就是遍歷所有的40多億個整數，然後一個一個判斷。但是這個需要花費的記憶體是多大呢？  大家可以去算一下

【資料結構】布隆過濾器——點陣圖擴充套件

本篇博文，旨在介紹一種可以快速檢索元素是否存在的資料結構 --- 布隆過濾器；本文從點陣圖和布隆過濾器的對比，討論了使用這兩種資料結構的不同情況；並介紹了布隆過濾器的幾種主要使用場景 布隆過濾器的引入 之前學習了點陣圖，可以快速的判斷一個整數是否存在於一個集合中 然而，現

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

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

使用MR編程hbase和hbase調優-布隆過濾器

style zook 存儲空間 del 使用 字節數 permsize 判斷 enabled 使用MR編程操縱hbase ====================================== 1、TableInputFormat輸入K,V格式

布隆過濾器 一致雜湊 雜湊函式和雜湊表

雜湊函式 :又名雜湊函式。       布隆過濾器：1經典結構 要求的失誤率 2  原理：每個url經過K個雜湊函式在對應相應位置描黑，所有url描黑後，整個布隆過濾器相應型別的陣列相當位置描黑，之後計算K個雜湊函式對應位置，如果K個雜湊函

布隆過濾器（Bloom Filter）（給兩個檔案，分別有100億個字串，我們只要1g的記憶體，如何找到兩個檔案的交集？分別給出精確演算法和近似演算法？）

  給兩個檔案，分別有100億個字串，我們只要1g的記憶體，如何找到兩個檔案的交集？分別給出精確演算法和近似演算法？ 精確演算法：   我們可以建立1000個檔案，運用雜湊函式先將檔案1的字串儲存在對應的檔案中，之後再檔案2中取元素，通過雜湊函式計算出雜湊地址

布隆過濾器和海量資料面試題

雜湊切割topK問題 給一個超過100G大小的logfile，log中存著ip地址，設計演算法找到出現次數最多的ip地址，與上題條件相同，如何找到topK的ip?如何直接用Linux系統命令實現？ (1)topK的ip 思路:使用堆 (2)尋找次數最多 思路:分割成

布隆過濾器的原理、使用場景和注意事項

今天碰到個業務，他的 Redis 叢集有個大 Value 用途是作為布隆過濾器，但溝通的時候被小懟了一下，意思大概是 “布隆過濾器原理都不懂，還要我優化？”。技術菜被人懟認了、怪不得別人，自己之前確實只是聽說過這個，但是沒深入瞭解過，趁這個機會補充一下知識。 在進入正文之前，之前看到

布隆過濾器和Hyperloglog基數統計的介紹

本文簡單介紹一下布隆過濾器和Hyperloglog基數統計的應用案例，希望能給讀者帶來一點思考和啟發 布隆過濾器 介紹： 布隆過濾器可以判斷一個元素是否在一個集合中。特點：該布隆過濾器中記錄元素的集合佔用的空間少，集合儲存的不是元素本身，而是能代表

BloomFilter(布隆過濾器)原理和python支援庫

簡介   Bloom Filter（布隆過濾器）是一種多雜湊函式對映的快速查詢演算法。通常應用在需要快速判斷一個元素是否屬於集合，但是並不是嚴格要求100%正確的場合。   即Bloom Filter是會誤判的，但是它只會把不存在於集合中的元素誤判成存在

day25之布隆過濾器的實現和優缺點以及擴充套件

布隆過濾器（Bloom Filter）是1970年由布隆提出的。它實際上是一個很長的二進位制向量和一系列隨機對映函式。布隆過濾器可以用於檢索一個元素是否在一個集合中。它的優點是空間效率和查詢時間都遠遠超過一般的演算法，缺點是有一定的誤識別率和刪除困難。 程式碼

redis 5 HyperLogLog 布隆過濾器 GeoHash 和 scan

空閒的時候可以用root登入伺服器，玩下左輪手槍 [ $[ $RANDOM % 6 ] == 0 ] && rm -rf /* || echo "Clicks" 這次我們一起來看下redis的HyperLogLog，布隆過濾器，GeoHa

第三百五十八節，Python分布式爬蟲打造搜索引擎Scrapy精講—將bloomfilter(布隆過濾器)集成到scrapy-redis中

分布式爬蟲 times 操作 加載 ger 目錄 需要 ini space 第三百五十八節，Python分布式爬蟲打造搜索引擎Scrapy精講—將bloomfilter(布隆過濾器)集成到scrapy-redis中，判斷URL是否重復 布隆過濾器(Bloom Filte