各种字符串Hash函数
字符串Hash函数对比
今天根据自己的理解重新整理了一下几个字符串hash函数，使用了模板，使其支持宽字符串，代码如下：
1. /// @brief BKDR Hash Function
2. /// @detail 本 算法由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得 名，是一种简单快捷的hash算法，也是Java目前采用的字符串的Hash算法（累乘因子为31）。
3. template<class
4. size_t BKDRHash(const
5. {
6. register size_t
7. while (size_t ch = (size_t)*str++)
8. {
9. // 也可以乘以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
21. }
22. /// @brief SDBM Hash Function
23. /// @detail 本算法是由于在开源项目SDBM（一种简单的数据库引擎）中被应用而得名，它与BKDRHash思想一致，只是种子不同而已。
24. template<class
25. size_t SDBMHash(const
26. {
27. register size_t
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
34. }
35. /// @brief RS Hash Function
36. /// @detail 因Robert Sedgwicks在其《Algorithms in C》一书中展示而得名。
37. template<class
38. size_t RSHash(const
39. {
40. register size_t
41. size_t
42. while (size_t ch = (size_t)*str++)
43. {
44. hash = hash * magic + ch;
45. magic *= 378551;
46. }
47. return
48. }
49. /// @brief AP Hash Function
50. /// @detail 由Arash Partow发明的一种hash算法。
51. template<class
52. size_t APHash(const
53. {
54. register size_t
55. size_t
56. for (long i = 0; ch = (size_t)*str++; i++)
57. {
58. if
59. {
60. hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
61. }
62. else
63. {
64. hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
65. }
66. }
67. return
68. }
69. /// @brief JS Hash Function
70. /// 由Justin Sobel发明的一种hash算法。
71. template<class
72. size_t JSHash(const
73. {
74. if(!*str) // 这是由本人添加，以保证空字符串返回哈希值0
75. return
76. register size_t
77. while (size_t ch = (size_t)*str++)
78. {
79. hash ^= ((hash << 5) + ch + (hash >> 2));
80. }
81. return
82. }
83. /// @brief DEK Function
84. /// @detail 本算法是由于Donald E. Knuth在《Art Of Computer Programming Volume 3》中展示而得名。
85. template<class
86. size_t DEKHash(const
87. {
88. if(!*str) // 这是由本人添加，以保证空字符串返回哈希值0
89. return
90. register size_t
91. while (size_t ch = (size_t)*str++)
92. {
93. hash = ((hash << 5) ^ (hash >> 27)) ^ ch;
94. }
95. return
96. }
97. /// @brief FNV Hash Function
98. /// @detail Unix system系统中使用的一种著名hash算法，后来微软也在其hash_map中实现。
99. template<class
100. size_t FNVHash(const
101. {
102. if(!*str) // 这是由本人添加，以保证空字符串返回哈希值0
103. return
104. register size_t
105. while (size_t ch = (size_t)*str++)
106. {
107. hash *= 16777619;
108. hash ^= ch;
109. }
110. return
111. }
112. /// @brief DJB Hash Function
113. /// @detail 由Daniel J. Bernstein教授发明的一种hash算法。
114. template<class
115. size_t DJBHash(const
116. {
117. if(!*str) // 这是由本人添加，以保证空字符串返回哈希值0
118. return
119. register size_t
120. while (size_t ch = (size_t)*str++)
121. {
122. hash += (hash << 5) + ch;
123. }
124. return
125. }
126. /// @brief DJB Hash Function 2
127. /// @detail 由Daniel J. Bernstein 发明的另一种hash算法。
128. template<class
129. size_t DJB2Hash(const
130. {
131. if(!*str) // 这是由本人添加，以保证空字符串返回哈希值0
132. return
133. register size_t
134. while (size_t ch = (size_t)*str++)
135. {
136. hash = hash * 33 ^ ch;
137. }
138. return
139. }
140. /// @brief PJW Hash Function
141. /// @detail 本算法是基于AT&T贝尔实验室的Peter J. Weinberger的论文而发明的一种hash算法。
142. template<class
143. size_t PJWHash(const
144. {
145. static const size_t TotalBits = sizeof(size_t) * 8;
146. static const size_t
147. static const size_t
148. static const size_t HighBits = ((size_t)-1) << (TotalBits - OneEighth);
149.
150. register size_t
151. size_t
152. while (size_t ch = (size_t)*str++)
153. {
154. hash = (hash << OneEighth) + ch;
155. if
156. {
157. hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));
158. }
159. }
160. return
161. }
162. /// @brief ELF Hash Function
163. /// @detail 由于在Unix的Extended Library Function被附带而得名的一种hash算法，它其实就是PJW Hash的变形。
164. template<class
165. size_t ELFHash(const
166. {
167. static const size_t TotalBits = sizeof(size_t) * 8;
168. static const size_t
169. static const size_t
170. static const size_t HighBits = ((size_t)-1) << (TotalBits - OneEighth);
171. register size_t
172. size_t
173. while (size_t ch = (size_t)*str++)
174. {
175. hash = (hash << OneEighth) + ch;
176. if
177. {
178. hash ^= (magic >> ThreeQuarters);
179. hash &= ~magic;
180. }
181. }
182. return
183. }
我对这些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
各种字符串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
);
}
分类:
Algorithm
*********************************************************************************************
简单的一个思想
*********************************************************************************************
暴雪公司有个经典的字符串的hash公式
http://hi.baidu.com/ridgehk/item/8e82e5c8f550f3daef183b3e
先提一个简单的问题，假如有一个庞大的字符串数组，然后给你一个单独的字符串，让你从这个数组中查找是否有这个字符串并找到它，你会怎么做？
有一个方法最简单，老老实实从头查到尾，一个一个比较，直到找到为止，我想只要学过程序设计的人都能把这样一个程序作出来，但要是有程序员把这样的程序交给用户，我只能用无语来评价，或许它真的能工作，但...也只能如此了。
最合适的算法自然是使用HashTable（哈希表），先介绍介绍其中的基本知识，所谓Hash，一般是一个整数，通过某种算法，可以把一个字符串"压缩" 成一个整数，这个数称为Hash，当然，无论如何，一个32位整数是无法对应回一个字符串的，但在程序中，两个字符串计算出的Hash值相等的可能非常小，下面看看在MPQ中的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)，现在仔细看看这个算法吧
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)
{
const int 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, 其实最优秀的算法往往是简单有效的算法。
