Blizzard hash to make an integer hash

Source: Internet
Author: User
Tags hash int size blizzard
questions raised

We often use it in the project to detect if an array B has the data in array A.
Scenario 1: Put the data in B into a bitmap and then use the data in a to probe.
Cons: If the data in B is sparse, such as [1,2,900,800], the bitmap is expensive because a bit is needed to identify the number that does not appear.
Scenario 2: The data in B is stored in a hash table and then detected using the data in a.
Blizzard hash principle see I reproduced before the article Blizzard hash
Taking Unordered_set as an example, it takes a lot of space to have all the data present in set. If the revised Blizzard hash algorithm is used, then a BOOL field can be used to identify the integer.
Source Reference Source
The source code of the integer hash function selection is as follows:

//header file #ifndef _uint64hash_h #define _UINT64HASH_H #include <string> using namespace std; #define MAXTABLELEN 1024//default hash Index Table size////////////////////////////////////////////////////////////////////////////  
    The hash Index table defines the typedef struct _HASHTABLE {uint64_t Nhasha;  
    uint64_t NHASHB;  
BOOL bexists;  

}hashtable, *phashtable;
    Class Uint64hash {Public:uint64hash (const long ntablelength = Maxtablelen);
~uint64hash (void);  
    private:uint64_t crypttable[0x500];    uint64_t m_tablelength; 
Hash Index table length HASHTABLE *m_hashindextable;                                               Private:void initcrypttable (); 
    Preprocessing of the hash Index table uint64_t HashUint64 (uint64_t key); 
    uint64_t hashuint64a (uint64_t key); 
uint64_t hashuint64b (uint64_t key);
    public:uint64_t Hash (uint64_t val);    BOOL Hashed (uint64_t val);
Detects if the URL has been hashed}; #endif 
#include <iostream> #include "Uint64Hash.h"//#include <boost/timer.hpp> #include <string> #include &

Lt;stdlib.h> using namespace std;  
    Uint64hash::uint64hash (const long ntablelength/*= maxtablelen*/) {initcrypttable ();  
    M_tablelength = Ntablelength;  
    Initialize hash Table m_hashindextable = new Hashtable[ntablelength];  
        for (int i = 0; i < ntablelength; i++) {M_hashindextable[i].nhasha =-1;  
        M_HASHINDEXTABLE[I].NHASHB =-1;  

    M_hashindextable[i].bexists = false; }} uint64hash::~uint64hash (void) {//Clean memory if (NULL! = m_hashindextable) {Delete []m  
        _hashindextable;  
        m_hashindextable = NULL;  
    m_tablelength = 0; }}/************************************************************************//* Function name: initcrypttable * Function: Preprocessing of hash Index Table *  
return value: No ************************************************************************/void uint64hash::initcrypttable ()  { 
    uint64_t seed = 0x00100001, index1 = 0, Index2 = 0, I; for (index1 = 0; index1 < 0x100; index1++) {for (Index2 = index1, i = 0; i < 5; i++, index2 + = 0x  
            (+) {uint64_t temp1, temp2;  
            Seed = (Seed * + 3)% 0x2aaaab;  
            Temp1 = (Seed & 0xFFFF) << 0x10;  
            Seed = (Seed * + 3)% 0x2aaaab;  
            Temp2 = (seed & 0xFFFF);   
        CRYPTTABLE[INDEX2] = (Temp1 | temp2);    
}}}/************************************************************************//* Function name: HashUint64 * Function: hash value is obtained * Return value: Return hash value ************************************************************************/uint64_t Uint64Hash:: 
  HashUint64 (uint64_t key) {key = (~key) + (key <<);//key = (key <<)-key-1; 
  Key = key ^ (key >> 24); Key = (key + (key << 3)) + (key << 8); 
  Key * 265 key = key ^ (key >> 14); Key = (kEY + (Key << 2) + (key << 4); 
  Key * key = key ^ (key >> 28); 
  Key = key + (key << 31); 


Return key;  } uint64_t uint64hash::hashuint64a (uint64_t key) {key = (~key) + (key <<);//key = (Key << 18) 
  -Key-1; 
  Key = key ^ (key >> 31); Key = key * 21; 
  Key = (key + (key << 2)) + (key << 4); 
  Key = key ^ (key >> 11); 
  Key = key + (key << 6); 
  Key = key ^ (key >> 22); 

Return key;  } uint64_t uint64hash::hashuint64b (uint64_t key) {key = ~key + (key <<);//key = (Key << 15)- 
  Key-1; 
  Key = key ^ (key >> 12); 
  Key = key + (key << 2); 
  Key = key ^ (key >> 4); Key = key * 2057; 
  Key = (key + (key << 3)) + (key << 11); 
  Key = key ^ (key >> 16); 

Return key; }/************************************************************************//* Function name: Hashed * Function: Detects if a string has been hashed * Return value: if present, 1; otherwise, return 0 *******/bool Uint64hash::hashed (uint64_t key) {//Not  
    The same string three-time hash will also collide with an infinite probability close to the impossible uint64_t Nhash = HashUint64 (key);  
    uint64_t Nhasha = hashuint64a (key);  
    uint64_t NHASHB = hashuint64b (key);  

    uint64_t Nhashstart = nhash% m_tablelength, nhashpos = Nhashstart;  while (m_hashindextable[nhashpos].bexists) {if (M_hashindextable[nhashpos].nhasha = = Nhasha &&   
        M_HASHINDEXTABLE[NHASHPOS].NHASHB = = NHASHB) return 1;  

        else Nhashpos = (nhashpos + 1)% M_tablelength;   
    if (Nhashpos = = Nhashstart) break; } return 0; Not found}/************************************************************************//* Function Name: hash * Function: Hash A String * return value: Success, return position, failure, return-1 ************************************************************************/uint64_t Uint64Hash:: Hash (uint64_t key) {uint64_t Nhash = HashUint64(key);  
    uint64_t Nhasha = hashuint64a (key);  
    uint64_t NHASHB = hashuint64b (key);  

    uint64_t Nhashstart = nhash% m_tablelength, nhashpos = Nhashstart;  
        while (m_hashindextable[nhashpos].bexists) {Nhashpos = (nhashpos + 1)% M_tablelength;   
        if (Nhashpos = = Nhashstart)//A Reincarnation {//hash table has no vacant position, can not complete the hash return-1;  
    }} m_hashindextable[nhashpos].bexists = true;  
    M_hashindextable[nhashpos].nhasha = Nhasha;  

    M_HASHINDEXTABLE[NHASHPOS].NHASHB = NHASHB;  
return nhashpos;
    } int main () {//Boost::timer t;
    const int SIZE = 5000000;
    Uint64hash s (size*2);
    for (int i = 0; i < SIZE; i++) {S.hash (i);
            } for (int i = 0; i < SIZE; i++) {if (!s.hashed (i)) {cout<< "ERROR" <<endl;
        Break

    }} cout<<t.elapsed () <<endl; for (int i = SIZE; i < 2*size; i++){if (s.hashed (i)) {cout<< "ERROR" << i<<endl;

}}//cout<<t.elapsed () <<endl; }

The Compile command is:
g++-o3–std=c++11
If you need to use a timer in boost to count the time, the compile command is:
unordered_set Comparison of g++-o3–std=c++11 *.cpp-lboost_system and STL

The code for Unordered_set is:

#include <iostream>
#include <unordered_set> 
#include <boost/timer.hpp>

using namespace Std;
int main () {
    Boost::timer t;
    const int SIZE = 5000000;

    unordered_set<int> s (SIZE);
    for (int i = 0; i < SIZE; i++) {
        s.insert (i);
    }
    for (int i = 0; i < SIZE; i++) {
        if (s.end ()  = = S.find (i)) {
            cout<< "ERROR" <<endl;
            break;
        }
    }
    cout<<t.elapsed () <<endl;
}

Time, Blizzard's hash function is much slower in time efficiency, after adding the O3 optimization option, on the 500W quantity, Blizzard's insertion and detection time is 1.11s,unordered_set: 0.46s.

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.