(轉自：http://blog.csdn.net/djinglan/article/details/8812934，感謝原作者)

今天根據自己的理解重新整理了一下幾個字符串hash函數，使用了模板，使其支持寬字符串，代碼如下：

[cpp]view
plaincopy

/// @brief BKDR Hash Function  

/// @detail 本 算法由於在Brian Kernighan與Dennis Ritchie的《The C Programming Language》一書被展示而得
名，是一種簡單快捷的hash算法，也是Java目前採用的字符串的Hash算法（累乘因子爲31）。  

template<class T>  

size_t BKDRHash(const T *str)  

{  

    register size_t hash = 0;  

    while (size_t ch = (size_t)*str++)  

    {         

        hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..  

        // 有人說將乘法分解爲位運算及加減法可以提高效率，如將上式表達爲：hash = hash << 7 + hash << 1 + hash + ch;  

        // 但其實在Intel平臺上，CPU內部對二者的處理效率都是差不多的，  

        // 我分別進行了100億次的上述兩種運算，發現二者時間差距基本爲0（如果是Debug版，分解成位運算後的耗時還要高1/3）；  

        // 在ARM這類RISC系統上沒有測試過，由於ARM內部使用Booth's Algorithm來模擬32位整數乘法運算，它的效率與乘數有關：  

        // 當乘數8-31位都爲1或0時，需要1個時鐘週期  

        // 當乘數16-31位都爲1或0時，需要2個時鐘週期  

        // 當乘數24-31位都爲1或0時，需要3個時鐘週期  

        // 否則，需要4個時鐘週期  

        // 因此，雖然我沒有實際測試，但是我依然認爲二者效率上差別不大          

    }  

    return hash;  

}  

/// @brief SDBM Hash Function  

/// @detail 本算法是由於在開源項目SDBM（一種簡單的數據庫引擎）中被應用而得名，它與BKDRHash思想一致，只是種子不同而已。  

template<class T>  

size_t SDBMHash(const T *str)  

{  

    register size_t hash = 0;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash = 65599 * hash + ch;         

        //hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;  

    }  

    return hash;  

}  

/// @brief RS Hash Function  

/// @detail 因Robert Sedgwicks在其《Algorithms in C》一書中展示而得名。  

template<class T>  

size_t RSHash(const T *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;  

}  

/// @brief AP Hash Function  

/// @detail 由Arash Partow發明的一種hash算法。  

template<class T>  

size_t APHash(const T *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;  

}  

/// @brief JS Hash Function  

/// 由Justin Sobel發明的一種hash算法。  

template<class T>  

size_t JSHash(const T *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;  

}  

/// @brief DEK Function  

/// @detail 本算法是由於Donald E. Knuth在《Art Of Computer Programming Volume 3》中展示而得名。  

template<class T>  

size_t DEKHash(const T* str)  

{  

    if(!*str)        // 這是由本人添加，以保證空字符串返回哈希值0  

        return 0;  

    register size_t hash = 1315423911;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash = ((hash << 5) ^ (hash >> 27)) ^ ch;  

    }  

    return hash;  

}  

/// @brief FNV Hash Function  

/// @detail Unix system系統中使用的一種著名hash算法，後來微軟也在其hash_map中實現。  

template<class T>  

size_t FNVHash(const T* str)  

{  

    if(!*str)   // 這是由本人添加，以保證空字符串返回哈希值0  

        return 0;  

    register size_t hash = 2166136261;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash *= 16777619;  

        hash ^= ch;  

    }  

    return hash;  

}  

/// @brief DJB Hash Function  

/// @detail 由Daniel J. Bernstein教授發明的一種hash算法。  

template<class T>  

size_t DJBHash(const T *str)  

{  

    if(!*str)   // 這是由本人添加，以保證空字符串返回哈希值0  

        return 0;  

    register size_t hash = 5381;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash += (hash << 5) + ch;  

    }  

    return hash;  

}  

/// @brief DJB Hash Function 2  

/// @detail 由Daniel J. Bernstein 發明的另一種hash算法。  

template<class T>  

size_t DJB2Hash(const T *str)  

{  

    if(!*str)   // 這是由本人添加，以保證空字符串返回哈希值0  

        return 0;  

    register size_t hash = 5381;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash = hash * 33 ^ ch;  

    }  

    return hash;  

}  

/// @brief PJW Hash Function  

/// @detail 本算法是基於AT&T貝爾實驗室的Peter J. Weinberger的論文而發明的一種hash算法。  

template<class T>  

size_t PJWHash(const T *str)  

{  

    static const size_t TotalBits       = sizeof(size_t) * 8;  

    static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  

    static const size_t OneEighth       = TotalBits / 8;  

    static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);      

    register size_t hash = 0;  

    size_t magic = 0;     

    while (size_t ch = (size_t)*str++)  

    {  

        hash = (hash << OneEighth) + ch;  

        if ((magic = hash & HighBits) != 0)  

        {  

            hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));  

        }  

    }  

    return hash;  

}  

/// @brief ELF Hash Function  

/// @detail 由於在Unix的Extended Library Function被附帶而得名的一種hash算法，它其實就是PJW Hash的變形。  

template<class T>  

size_t ELFHash(const T *str)  

{  

    static const size_t TotalBits       = sizeof(size_t) * 8;  

    static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  

    static const size_t OneEighth       = TotalBits / 8;  

    static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);      

    register size_t hash = 0;  

    size_t magic = 0;  

    while (size_t ch = (size_t)*str++)  

    {  

        hash = (hash << OneEighth) + ch;  

        if ((magic = hash & HighBits) != 0)  

        {  

            hash ^= (magic >> ThreeQuarters);  

            hash &= ~magic;  

        }         

    }  

    return hash;  

}

我對這些hash的散列質量及效率作了一個簡單測試，測試結果如下：

測試1：對100000個由大小寫字母與數字隨機的ANSI字符串（無重複，每個字符串最大長度不超過64字符）進行散列：

字符串函數	衝突數	除1000003取餘後的衝突數
BKDRHash	0	4826
SDBMHash	2	4814
RSHash	2	4886
APHash	0	4846
ELFHash	1515	6120
JSHash	779	5587
DEKHash	863	5643
FNVHash	2	4872
DJBHash	832	5645
DJB2Hash	695	5309
PJWHash	1515	6120

測試2：對100000個由任意UNICODE組成隨機字符串（無重複，每個字符串最大長度不超過64字符）進行散列：

字符串函數	衝突數	除1000003取餘後的衝突數
BKDRHash	3	4710
SDBMHash	3	4904
RSHash	3	4822
APHash	2	4891
ELFHash	16	4869
JSHash	3	4812
DEKHash	1	4755
FNVHash	1	4803
DJBHash	1	4749
DJB2Hash	2	4817
PJWHash	16	4869

測試3：對1000000個隨機ANSI字符串（無重複，每個字符串最大長度不超過64字符）進行散列：

字符串函數	耗時（毫秒）
BKDRHash	109
SDBMHash	109
RSHash	124
APHash	187
ELFHash	249
JSHash	172
DEKHash	140
FNVHash	125
DJBHash	125
DJB2Hash	125
PJWHash	234

結論：也許是我的樣本存在一些特殊性，在對ASCII碼字符串進行散列時，PJW與ELF Hash（它們其實是同一種算法）無論是質量還是效率，都相當糟糕；例如："b5"與“aE"，這兩個字符串按照PJW散列出來的hash值就是一樣的。另外，其它幾種依靠異或來散列的哈希函數，如：JS/DEK/DJB Hash，在對字母與數字組成的字符串的散列效果也不怎麼好。相對而言，還是BKDR與SDBM這類簡單的Hash效率與效果更好。

其他：

作者：icefireelf

出處：http://blog.csdn.net/icefireelf/article/details/5796529

各種字符串Hash函數比較

常用的字符串Hash函數還有ELFHash，APHash等等，都是十分簡單有效的方法。這些函數使用位運算使得每一個字符都對最後的函數值產生影響。另外還有以MD5和SHA1爲代表的雜湊函數，這些函數幾乎不可能找到碰撞。

常用字符串哈希函數有 BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。對於以上幾種哈希函數，我對其進行了一個小小的評測。

Hash函數	數據1	數據2	數據3	數據4	數據1得分	數據2得分	數據3得分	數據4得分	平均分
BKDRHash	2	0	4774	481	96.55	100	90.95	82.05	92.64
APHash	2	3	4754	493	96.55	88.46	100	51.28	86.28
DJBHash	2	2	4975	474	96.55	92.31	0	100	83.43
JSHash	1	4	4761	506	100	84.62	96.83	17.95	81.94
RSHash	1	0	4861	505	100	100	51.58	20.51	75.96
SDBMHash	3	2	4849	504	93.1	92.31	57.01	23.08	72.41
PJWHash	30	26	4878	513	0	0	43.89	0	21.95
ELFHash	30	26	4878	513	0	0	43.89	0	21.95

其中數據1爲100000個字母和數字組成的隨機串哈希衝突個數。數據2爲100000個有意義的英文句子哈希衝突個數。數據3爲數據1的哈希值與 1000003(大素數)求模後存儲到線性表中衝突的個數。數據4爲數據1的哈希值與10000019(更大素數)求模後存儲到線性表中衝突的個數。

經過比較，得出以上平均得分。平均數爲平方平均數。可以發現，BKDRHash無論是在實際效果還是編碼實現中，效果都是最突出的。APHash也是較爲優秀的算法。DJBHash,JSHash,RSHash與SDBMHash各有千秋。PJWHash與ELFHash效果最差，但得分相似，其算法本質是相似的。

unsigned int SDBMHash(char *str)
{
    unsigned int hash = 0;

    while (*str)
    {
        // equivalent to: hash = 65599*hash + (*str++);
        hash = (*str++) + (hash << 6) + (hash << 16) - hash;
    }

    return (hash & 0x7FFFFFFF);
}

// RS Hash Function
unsigned int RSHash(char *str)
{
    unsigned int b = 378551;
    unsigned int a = 63689;
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * a + (*str++);
        a *= b;
    }

    return (hash & 0x7FFFFFFF);
}

// JS Hash Function
unsigned int JSHash(char *str)
{
    unsigned int hash = 1315423911;

    while (*str)
    {
        hash ^= ((hash << 5) + (*str++) + (hash >> 2));
    }

    return (hash & 0x7FFFFFFF);
}

// P. J. Weinberger Hash Function
unsigned int PJWHash(char *str)
{
    unsigned int BitsInUnignedInt = (unsigned int)(sizeof(unsigned int) * 8);
    unsigned int ThreeQuarters    = (unsigned int)((BitsInUnignedInt  * 3) / 4);
    unsigned int OneEighth        = (unsigned int)(BitsInUnignedInt / 8);
    unsigned int HighBits         = (unsigned int)(0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    unsigned int hash             = 0;
    unsigned int test             = 0;

    while (*str)
    {
        hash = (hash << OneEighth) + (*str++);
        if ((test = hash & HighBits) != 0)
        {
            hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
        }
    }

    return (hash & 0x7FFFFFFF);
}

// ELF Hash Function
unsigned int ELFHash(char *str)
{
    unsigned int hash = 0;
    unsigned int x    = 0;

    while (*str)
    {
        hash = (hash << 4) + (*str++);
        if ((x = hash & 0xF0000000L) != 0)
        {
            hash ^= (x >> 24);
            hash &= ~x;
        }
    }

    return (hash & 0x7FFFFFFF);
}

// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * seed + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

// DJB Hash Function
unsigned int DJBHash(char *str)
{
    unsigned int hash = 5381;

    while (*str)
    {
        hash += (hash << 5) + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

// AP Hash Function
unsigned int APHash(char *str)
{
    unsigned int hash = 0;
    int i;

    for (i=0; *str; i++)
    {
        if ((i & 1) == 0)
        {
            hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
        }
        else
        {
            hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
        }
    }

    return (hash & 0x7FFFFFFF);
}

http://www.byvoid.com/blog/string-hash-compare/

分類: Algorithm

*********************************************************************************************
簡單的一個思想
*********************************************************************************************
暴雪公司有個經典的字符串的hash公式
http://blog.csdn.net/guoxiaoqian8028/article/details/30241031
先提一個簡單的問題，假如有一個龐大的字符串數組，然後給你一個單獨的字符串，讓你從這個數組中查找是否有這個字符串並找到它，你會怎麼做？

有一個方法最簡單，老老實實從頭查到尾，一個一個比較，直到找到爲止，我想只要學過程序設計的人都能把這樣一個程序作出來，但要是有程序員把這樣的程序交給用戶，我只能用無語來評價，或許它真的能工作，但...也只能如此了。

最合適的算法自然是使用HashTable（哈希表），先介紹介紹其中的基本知識，所謂Hash，一般是一個整數，通過某種算法，可以把一個字符串"壓縮" 成一個整數，這個數稱爲Hash，當然，無論如何，一個32位整數是無法對應回一個字符串的，但在程序中，兩個字符串計算出的Hash值相等的可能非常小，下面看看在MPQ中的Hash算法

以下的函數生成一個長度爲0x500（合10進制數：1280）的cryptTable[0x500]

void prepareCryptTable()
{
    unsigned long seed = 0x00100001, index1 = 0, index2 = 0, i;
    for( index1 = 0; index1 < 0x100; index1++ )
    {
        for( index2 = index1, i = 0; i < 5; i++, index2 += 0x100 )
        {
            unsigned long temp1, temp2;
            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp1 = (seed & 0xFFFF) << 0x10;
            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp2 = (seed & 0xFFFF);
            cryptTable[index2] = ( temp1 | temp2 );
       }
   }
}

以下函數計算lpszFileName 字符串的hash值，其中dwHashType 爲hash的類型，在下面GetHashTablePos函數裏面調用本函數，其可以取的值爲0、1、2；該函數返回lpszFileName 字符串的hash值；

unsigned long HashString(char*lpszFileName, unsigned long dwHashType)   
{   
    unsigned char*key = (unsigned char*)lpszFileName;   
    unsigned long seed1 =0x7FED7FED, seed2 =0xEEEEEEEE;   
    int ch;   
  
    while(*key !=0)   
    {   
        ch = toupper(*key );   
  
        seed1 = cryptTable[(dwHashType <<8) + ch] ^ (seed1 + seed2);   
        seed2 = ch+ seed1+ seed2 +(seed2 <<5) + 3;   
    }   
    return seed1;   
}

Blizzard的這個算法是非常高效的，被稱爲"One-Way Hash"，舉個例子，字符串"unitneutralacritter.grp"通過這個算法得到的結果是0xA26067F3。
是不是把第一個算法改進一下，改成逐個比較字符串的Hash值就可以了呢，答案是，遠遠不夠，要想得到最快的算法，就不能進行逐個的比較，通常是構造一個哈希表(Hash Table)來解決問題，哈希表是一個大數組，這個數組的容量根據程序的要求來定義，例如1024，每一個Hash值通過取模運算 (mod)對應到數組中的一個位置，這樣，只要比較這個字符串的哈希值對應的位置又沒有被佔用，就可以得到最後的結果了，想想這是什麼速度？是的，是最快的O(1)，現在仔細看看這個算法吧

typedef struct
{
    int nHashA;
    int nHashB;
    char bExists;
   ......
} SOMESTRUCTRUE;//<span style="color: rgb(54, 46, 43); font-family: Arial; font-size: 14px; line-height: 26px;">一種可能的結構體定義？</span>

lpszString 爲要在hash表中查找的字符串；lpTable 爲存儲字符串hash值的hash表

int GetHashTablePos(char*lpszString, SOMESTRUCTURE *lpTable, int nTableSize)   
{   
    int nHash = HashString(lpszString), nHashPos = nHash % nTableSize;   
  
    if (lpTable[nHashPos].bExists &&!strcmp(lpTable[nHashPos].pString, lpszString))   
        return nHashPos;   
    else   
        return-1; //Error value   
}

看到此，我想大家都在想一個很嚴重的問題："假如兩個字符串在哈希表中對應的位置相同怎麼辦？",究竟一個數組容量是有限的，這種可能性很大。解決該問題的方法很多，我首先想到的就是用"鏈表",感謝大學裏學的數據結構教會了這個百試百靈的法寶，我碰到的很多算法都可以轉化成鏈表來解決，只要在哈希表的每個入口掛一個鏈表，保存所有對應的字符串就OK了。

事情到此似乎有了完美的結局，假如是把問題獨自交給我解決，此時我可能就要開始定義數據結構然後寫代碼了。然而Blizzard的程序員使用的方法則是更精妙的方法。基本原理就是：他們在哈希表中不是用一個哈希值而是用三個哈希值來校驗字符串。

中國有句古話"再一再二不能再三再四"，看來Blizzard也深得此話的精髓，假如說兩個不同的字符串經過一個哈希算法得到的入口點一致有可能，但用三個不同的哈希算法算出的入口點都一致，那幾乎可以肯定是不可能的事了，這個機率是1:18889465931478580854784，大概是10的 22.3次方分之一，對一個遊戲程序來說足夠安全了。

現在再回到數據結構上，Blizzard使用的哈希表沒有使用鏈表，而採用"順延"的方式來解決問題，看看這個算法：

int GetHashTablePos(char*lpszString, MPQHASHTABLE *lpTable, int nTableSize)   
{   
    constint HASH_OFFSET =0, HASH_A =1, HASH_B =2;   
    int nHash = HashString(lpszString, HASH_OFFSET);   
    int nHashA = HashString(lpszString, HASH_A);   
    int nHashB = HashString(lpszString, HASH_B);   
    int nHashStart = nHash % nTableSize, nHashPos = nHashStart;   
      
    while (lpTable[nHashPos].bExists)   
    {   
        if (lpTable[nHashPos].nHashA == nHashA && lpTable[nHashPos].nHashB == nHashB)   
            return nHashPos;   
        else   
            nHashPos = (nHashPos +1) % nTableSize;   
          
        if (nHashPos == nHashStart)   
            break;   
    }   
  
    return-1; //Error value   
}

1. 計算出字符串的三個哈希值（一個用來確定位置，另外兩個用來校驗)
2. 察看哈希表中的這個位置
3. 哈希表中這個位置爲空嗎？假如爲空，則肯定該字符串不存在，返回
4. 假如存在，則檢查其他兩個哈希值是否也匹配，假如匹配，則表示找到了該字符串，返回
5. 移到下一個位置，假如已經越界，則表示沒有找到，返回
6. 看看是不是又回到了原來的位置，假如是，則返回沒找到
7. 回到3

怎麼樣，很簡單的算法吧，但確實是天才的idea, 其實最優秀的算法往往是簡單有效的算法。

經典字符串hash函數介紹及性能比較 + 暴雪公司hash算法

各種字符串Hash函數比較

網易互娛2017實習生招聘在線筆試（二）

android判斷手機是否支持某種語言

android 多語言設置沒法切到印尼語

Android NDK: Could not find application project directory

十七道海量數據處理面試題與Bit-map詳解

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結