经典字符串hash函数介绍及性能比较 + 暴雪公司hash算法

2019年4月18日 116次阅读 来源: 秋风知劲草 
(转自：http://blog.csdn.net/djinglan/article/details/8812934，感谢原作者)
今天根据自己的理解重新整理了一下几个字符串hash函数，使用了模板，使其支持宽字符串，代码如下：

[cpp] 
view plain
copy

  1. /// @brief BKDR Hash Function  
  2. /// @detail 本 算法由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得 名，是一种简单快捷的hash算法，也是Java目前采用的字符串的Hash算法（累乘因子为31）。  
  3. template<class T>  
  4. size_t BKDRHash(const T *str)  
  5. {  
  6.     register size_t hash = 0;  
  7.     while (size_t ch = (size_t)*str++)  
  8.     {         
  9.         hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..  
  10.         // 有人说将乘法分解为位运算及加减法可以提高效率，如将上式表达为：hash = hash << 7 + hash << 1 + hash + ch;  
  11.         // 但其实在Intel平台上，CPU内部对二者的处理效率都是差不多的，  
  12.         // 我分别进行了100亿次的上述两种运算，发现二者时间差距基本为0（如果是Debug版，分解成位运算后的耗时还要高1/3）；  
  13.         // 在ARM这类RISC系统上没有测试过，由于ARM内部使用Booth’s Algorithm来模拟32位整数乘法运算，它的效率与乘数有关：  
  14.         // 当乘数8-31位都为1或0时，需要1个时钟周期  
  15.         // 当乘数16-31位都为1或0时，需要2个时钟周期  
  16.         // 当乘数24-31位都为1或0时，需要3个时钟周期  
  17.         // 否则，需要4个时钟周期  
  18.         // 因此，虽然我没有实际测试，但是我依然认为二者效率上差别不大          
  19.     }  
  20.     return hash;  
  21. }  
  22. /// @brief SDBM Hash Function  
  23. /// @detail 本算法是由于在开源项目SDBM（一种简单的数据库引擎）中被应用而得名，它与BKDRHash思想一致，只是种子不同而已。  
  24. template<class T>  
  25. size_t SDBMHash(const T *str)  
  26. {  
  27.     register size_t hash = 0;  
  28.     while (size_t ch = (size_t)*str++)  
  29.     {  
  30.         hash = 65599 * hash + ch;         
  31.         //hash = (size_t)ch + (hash << 6) + (hash << 16) – hash;  
  32.     }  
  33.     return hash;  
  34. }  
  35. /// @brief RS Hash Function  
  36. /// @detail 因Robert Sedgwicks在其《Algorithms in C》一书中展示而得名。  
  37. template<class T>  
  38. size_t RSHash(const T *str)  
  39. {  
  40.     register size_t hash = 0;  
  41.     size_t magic = 63689;     
  42.     while (size_t ch = (size_t)*str++)  
  43.     {  
  44.         hash = hash * magic + ch;  
  45.         magic *= 378551;  
  46.     }  
  47.     return hash;  
  48. }  
  49. /// @brief AP Hash Function  
  50. /// @detail 由Arash Partow发明的一种hash算法。  
  51. template<class T>  
  52. size_t APHash(const T *str)  
  53. {  
  54.     register size_t hash = 0;  
  55.     size_t ch;  
  56.     for (long i = 0; ch = (size_t)*str++; i++)  
  57.     {  
  58.         if ((i & 1) == 0)  
  59.         {  
  60.             hash ^= ((hash << 7) ^ ch ^ (hash >> 3));  
  61.         }  
  62.         else  
  63.         {  
  64.             hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));  
  65.         }  
  66.     }  
  67.     return hash;  
  68. }  
  69. /// @brief JS Hash Function  
  70. /// 由Justin Sobel发明的一种hash算法。  
  71. template<class T>  
  72. size_t JSHash(const T *str)  
  73. {  
  74.     if(!*str)        // 这是由本人添加，以保证空字符串返回哈希值0  
  75.         return 0;  
  76.     register size_t hash = 1315423911;  
  77.     while (size_t ch = (size_t)*str++)  
  78.     {  
  79.         hash ^= ((hash << 5) + ch + (hash >> 2));  
  80.     }  
  81.     return hash;  
  82. }  
  83. /// @brief DEK Function  
  84. /// @detail 本算法是由于Donald E. Knuth在《Art Of Computer Programming Volume 3》中展示而得名。  
  85. template<class T>  
  86. size_t DEKHash(const T* str)  
  87. {  
  88.     if(!*str)        // 这是由本人添加，以保证空字符串返回哈希值0  
  89.         return 0;  
  90.     register size_t hash = 1315423911;  
  91.     while (size_t ch = (size_t)*str++)  
  92.     {  
  93.         hash = ((hash << 5) ^ (hash >> 27)) ^ ch;  
  94.     }  
  95.     return hash;  
  96. }  
  97. /// @brief FNV Hash Function  
  98. /// @detail Unix system系统中使用的一种著名hash算法，后来微软也在其hash_map中实现。  
  99. template<class T>  
  100. size_t FNVHash(const T* str)  
  101. {  
  102.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
  103.         return 0;  
  104.     register size_t hash = 2166136261;  
  105.     while (size_t ch = (size_t)*str++)  
  106.     {  
  107.         hash *= 16777619;  
  108.         hash ^= ch;  
  109.     }  
  110.     return hash;  
  111. }  
  112. /// @brief DJB Hash Function  
  113. /// @detail 由Daniel J. Bernstein教授发明的一种hash算法。  
  114. template<class T>  
  115. size_t DJBHash(const T *str)  
  116. {  
  117.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
  118.         return 0;  
  119.     register size_t hash = 5381;  
  120.     while (size_t ch = (size_t)*str++)  
  121.     {  
  122.         hash += (hash << 5) + ch;  
  123.     }  
  124.     return hash;  
  125. }  
  126. /// @brief DJB Hash Function 2  
  127. /// @detail 由Daniel J. Bernstein 发明的另一种hash算法。  
  128. template<class T>  
  129. size_t DJB2Hash(const T *str)  
  130. {  
  131.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
  132.         return 0;  
  133.     register size_t hash = 5381;  
  134.     while (size_t ch = (size_t)*str++)  
  135.     {  
  136.         hash = hash * 33 ^ ch;  
  137.     }  
  138.     return hash;  
  139. }  
  140. /// @brief PJW Hash Function  
  141. /// @detail 本算法是基于AT&T贝尔实验室的Peter J. Weinberger的论文而发明的一种hash算法。  
  142. template<class T>  
  143. size_t PJWHash(const T *str)  
  144. {  
  145.     static const size_t TotalBits       = sizeof(size_t) * 8;  
  146.     static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  
  147.     static const size_t OneEighth       = TotalBits / 8;  
  148.     static const size_t HighBits        = ((size_t)-1) << (TotalBits – OneEighth);      
  149.       
  150.     register size_t hash = 0;  
  151.     size_t magic = 0;     
  152.     while (size_t ch = (size_t)*str++)  
  153.     {  
  154.         hash = (hash << OneEighth) + ch;  
  155.         if ((magic = hash & HighBits) != 0)  
  156.         {  
  157.             hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));  
  158.         }  
  159.     }  
  160.     return hash;  
  161. }  
  162. /// @brief ELF Hash Function  
  163. /// @detail 由于在Unix的Extended Library Function被附带而得名的一种hash算法，它其实就是PJW Hash的变形。  
  164. template<class T>  
  165. size_t ELFHash(const T *str)  
  166. {  
  167.     static const size_t TotalBits       = sizeof(size_t) * 8;  
  168.     static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  
  169.     static const size_t OneEighth       = TotalBits / 8;  
  170.     static const size_t HighBits        = ((size_t)-1) << (TotalBits – OneEighth);      
  171.     register size_t hash = 0;  
  172.     size_t magic = 0;  
  173.     while (size_t ch = (size_t)*str++)  
  174.     {  
  175.         hash = (hash << OneEighth) + ch;  
  176.         if ((magic = hash & HighBits) != 0)  
  177.         {  
  178.             hash ^= (magic >> ThreeQuarters);  
  179.             hash &= ~magic;  
  180.         }         
  181.     }  
  182.     return hash;  
  183. }  

 

我对这些hash的散列质量及效率作了一个简单测试，测试结果如下：

测试1：对100000个由大小写字母与数字随机的ANSI字符串（无重复，每个字符串最大长度不超过64字符）进行散列：

字符串函数冲突数除1000003取余后的冲突数

BKDRHash

04826

SDBMHash

24814

RSHash

24886

APHash

04846

ELFHash

15156120

JSHash

7795587

DEKHash

8635643

FNVHash

24872

DJBHash

8325645

DJB2Hash

6955309

PJWHash

15156120

 

测试2：对100000个由任意UNICODE组成随机字符串（无重复，每个字符串最大长度不超过64字符）进行散列：

字符串函数冲突数除1000003取余后的冲突数

BKDRHash

34710

SDBMHash

34904

RSHash

34822

APHash

24891

ELFHash

164869

JSHash

34812

DEKHash

14755

FNVHash

14803

DJBHash

14749

DJB2Hash

24817

PJWHash

164869

 

测试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得分平均分
BKDRHash20477448196.5510090.9582.0592.64
APHash23475449396.5588.4610051.2886.28
DJBHash22497547496.5592.31010083.43
JSHash14476150610084.6296.8317.9581.94
RSHash10486150510010051.5820.5175.96
SDBMHash32484950493.192.3157.0123.0872.41
PJWHash302648785130043.89021.95
ELFHash302648785130043.89021.95

其中数据1为100000个字母和数字组成的随机串哈希冲突个数。数据2为100000个有意义的英文句子哈希冲突个数。数据3为数据1的哈希值与 1000003(大素数)求模后存储到线性表中冲突的个数。数据4为数据1的哈希值与10000019(更大素数)求模后存储到线性表中冲突的个数。

经过比较，得出以上平均得分。平均数为平方平均数。可以发现，BKDRHash无论是在实际效果还是编码实现中，效果都是最突出的。APHash也 是较为优秀的算法。DJBHash,JSHash,RSHash与SDBMHash各有千秋。PJWHash与ELFHash效果最差，但得分相似，其算 法本质是相似的。

 

《经典字符串hash函数介绍及性能比较 + 暴雪公司hash算法》
《经典字符串hash函数介绍及性能比较 + 暴雪公司hash算法》
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
);
}
《经典字符串hash函数介绍及性能比较 + 暴雪公司hash算法》
《经典字符串hash函数介绍及性能比较 + 暴雪公司hash算法》

 

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, 其实最优秀的算法往往是简单有效的算法。

    原文作者：秋风知劲草
    原文地址: https://blog.csdn.net/xu20082100226/article/details/52651212
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞