字符串hash算法比较 AND 经典HASH函数

傷城~ 2022-08-27 05:48 134阅读 0赞

**字符串的算法一般大公司都会考到，我们首先要想到高效的hash。如百度查找一组字符串是否出现在某个文本中，这个不是考什么kmp，他们想听到的是hash。趋势科技考的是从某个文本中删除一组字符串，我想也是要hash吧。**

**1 概述**

<table> 
 <tbody> 
  <tr> 
   <td>链表<font>查找</font>的时间效率为O(N)，二分法为log2N，B+ Tree为log2N，但<font>Hash</font>链表<font>查找</font>的时间效率为O(1)。</td> 
  </tr> 
 </tbody> 
</table>

设计高效算法往往需要使用 Hash链表，常数级的 查找速度是任何别的算法无法比拟的， Hash链表的构造和冲突的不同实现方法对效率当然有一定的影响，然 而 Hash函数是 Hash链表最核心的部分，本文尝试分析一些经典软件中使用到的字符串 Hash函数在执行效率、离散性、空间利用率等方面的性能问题。

<table> 
 <tbody> 
  <tr> 
   <td><strong>2 经典字符串<font>Hash</font>函数介绍</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>作者阅读过大量经典软件原代码，下面分别介绍几个经典软件中出现的字符串<font>Hash</font>函数。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>2.1 PHP中出现的字符串<font>Hash</font>函数</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>static unsigned long <font>hash</font>pjw(char *arKey, unsigned int nKeyLength)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long h = 0, g;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>char *arEnd=arKey+nKeyLength;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>while (arKey &lt; arEnd) { </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>h = (h &lt;&lt; 4) + *arKey++;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return h;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>2.2 OpenSSL中出现的字符串<font>Hash</font>函数</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long lh_str<font>hash</font>(char *str)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long ret=0;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned short *s;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>if (str == NULL) return(0);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>l=(strlen(str)+1)/2;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>s=(unsigned short *)str;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return(ret);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>/* The following <font>hash</font> seems to work very well on normal text strings</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* no collisions on /usr/dict/words and it distributes on %2^n quite</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* well, not as good as MD5, but still good.</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long lh_str<font>hash</font>(const char *c)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long ret=0;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned long v;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return(ret);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned char b[16];</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>MD5(c,strlen(c),b);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return(b[0]|(b[1]&lt;&lt;8)|(b[2]&lt;&lt;16)|(b[3]&lt;&lt;24));</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>while (*c)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>ret&amp;=0xFFFFFFFFL;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return((ret&gt;&gt;16)^ret);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>在下面的测量过程中我们分别将上面的两个函数标记为OpenSSL_<font>Hash</font>1和OpenSSL_<font>Hash</font>2，至于上面的实现中使用MD5算法的实现函数我们不作测试。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>2.3 MySql中出现的字符串<font>Hash</font>函数</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>#ifndef NEW_<font>HASH</font>_FUNCTION</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>/* Calc <font>hash</font>value for a key */</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>static uint calc_<font>hash</font>nr(const byte *key,uint length)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>register uint nr=1, nr2=4;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>while (length--)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>nr^= (((nr &amp; 63)+nr2)*((uint) (uchar) *key++))+ (nr &lt;&lt; 8);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return((uint) nr);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>/* Calc <font>hash</font>value for a key, case indepenently */</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>static uint calc_<font>hash</font>nr_caseup(const byte *key,uint length)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>register uint nr=1, nr2=4;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>while (length--)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>nr^= (((nr &amp; 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr &lt;&lt; 8);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return((uint) nr);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* Fowler/Noll/Vo <font>hash</font></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* The basis of the <font>hash</font> algorithm was taken from an idea sent by email to the</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* Glenn Fowler (gsf@research.att.com). Landon Curt Noll (chongo@toad.com)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* later improved on their algorithm.</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* The magic is in the interesting relationship between the special prime</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* This <font>hash</font> produces the fewest collisions of any function that we've seen so</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>* far, and works well on both numbers and strings.</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>uint calc_<font>hash</font>nr(const byte *key, uint len)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>const byte *end=key+len;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><font>hash</font> ^= (uint) *(uchar*) key;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return (<font>hash</font>);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>uint calc_<font>hash</font>nr_caseup(const byte *key, uint len)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>const byte *end=key+len;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><font>hash</font> ^= (uint) (uchar) toupper(*key);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return (<font>hash</font>);</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>#endif</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>Mysql中对字符串<font>Hash</font>函数还区分了大小写，我们的测试中使用不区分大小写的字符串<font>Hash</font>函数，另外我们将上面的两个函数分别记为MYSQL_<font>Hash</font>1和MYSQL_<font>Hash</font>2。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>2.4 另一个经验字符串<font>Hash</font>函数</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>unsigned int <font>hash</font>(char *str)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>register unsigned int h;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>register unsigned char *p;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>for(h=0, p = (unsigned char *)str; *p ; p++)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>return h;</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>3 测试及结果</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>从上面给出的经典字符串<font>Hash</font>函 数中可以看出，有的涉及到字符串大小敏感问题，我们的测试中只考虑字符串大小写敏感的函数，另外在上面的函数中有的函数 需要长度参数，有的不需要长度参数，这对函数本身的效率有一定的影响，我们的测试中将对函数稍微作一点修改，全部使用长度参数，并将函数内部出现的计算长 度代码删除。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>我们用来作测试用的<font>Hash</font>链表采用经典的拉链法解决冲突，另外我们采用静态分配桶（<font>Hash</font>链表长度）的方法来构造<font>Hash</font>链表，这主要是为了简化我们的实现，并不影响我们的测试结果。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>测试文本采用单词表，测试过程中从一个输入文件中读取全部不重复单词构造一个<font>Hash</font>表，测试内容分别是函数总调用次数、函数总调用时间、最大拉链长度、 平均拉链长度、桶利用率（使用过的桶所占的比率），其中函数总调用次数是指<font>Hash</font>函数被调用的总次数，为了测试出函数执行时间，该值在测试过程中作了一 定的放大，函数总调用时间是指<font>Hash</font>函数总的执行时间，最大拉链长度是指使用拉链法构造链表过程中出现的最大拉链长度，平均拉链长度指拉链的平均长度。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>测试过程中使用的机器配置如下：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>PIII600笔记本，128M内存，windows 2000 server操作系统。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>以下分别是对两个不同文本文件中的全部不重复单词构造<font>Hash</font>链表的测试结果，测试结果中函数调用次数放大了100倍，相应的函数调用时间也放大了100倍。</td> 
  </tr> 
 </tbody> 
</table>

**从上表可以看出，这些经典软件虽然构造字符串Hash函数的方法不同，但是它们的效率都是不错的，相互之间差距很小，读者可以参考实际情况从其中借鉴使用。**