ELFhash

 ELFhash - 优秀的字符串哈希算法

2016年10月29日 22:12:37 阅读数：6440更多

个人分类： 算法杂论 算法精讲 数据结构

所属专栏： 算法与数据结构

 

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ltyqljhwcm/article/details/52966874

1.字符串哈希：

我们先从字符串哈希说起

在很多的情况下，我们有可能会获得大量的字符串，每个字符串有可能重复也有可能不重复

C不像Python有字典类型的数据结构，我们没有办法吧字符串当做是键值来保存，所以说我们需要一种hash函数将每个字符串都尽可能减少冲突的情况下去应设一个唯一的整形数据，方便我们的保存，这里我们就引入了字符串hash算法

 

现在，有非常多的字符串hash算法都很优秀，本文主要面对ELFhash算法来表述，相对来说比较的清晰

2.ELFhash

首先我需要声明，字符串hash算法ELFhash的算法的形成的三列的均匀性我不会证明

根据其他的大牛的描述，ELFhash算法对于长字符串和短字符串都有优良的效率，以下的数据援引刘爱贵大神的实验数据：

 

Hash应用中，字符串是最为常见的关键字，应用非常普通，现在的程序设计语言中基本上都提供了字符串hash表的支持。字符串hash函数非常多，常见的主要有Simple_hash, RS_hash, JS_hash, PJW_hash, ELF_hash, BKDR_hash, SDBM_hash, DJB_hash, AP_hash, CRC_hash等。它们的C语言实现见后面附录代码: hash.h, hash.c。那么这么些字符串hash函数，谁好熟非呢？评估hash函数优劣的基准主要有以下两个指标：

(1) 散列分布性

即桶的使用率backet_usage = (已使用桶数) / (总的桶数)，这个比例越高，说明分布性良好，是好的hash设计。

(2) 平均桶长

即avg_backet_len，所有已使用桶的平均长度。理想状态下这个值应该=1，越小说明冲突发生地越少，是好的hash设计。

hash函数计算一般都非常简洁，因此在耗费计算时间复杂性方面判别甚微，这里不作对比。

 

评估方案设计是这样的：

(1) 以200M的视频文件作为输入源，以4KB的块为大小计算MD5值，并以此作为hash关键字;

(2) 分别应用上面提到的各种字符串hash函数，进行hash散列模拟；

(3) 统计结果，用散列分布性和平均桶长两个指标进行评估分析。

 

测试程序见附录代码hashtest.c，测试结果如下表所示。从这个结果我们也可以看出，这些字符串hash函数真是不相仲伯，难以决出高低，所以实际应用中可以根据喜好选择。当然，最好实际测试一下，毕竟应用特点不大相同。其他几组测试结果也类似，这里不再给出。

 

Hash函数	桶数	Hash调用总数	最大桶长	平均桶长	桶使用率%
simple_hash	10240	47198	16	4.63	99.00%
RS_hash	10240	47198	16	4.63	98.91%
JS_hash	10240	47198	15	4.64	98.87%
PJW_hash	10240	47198	16	4.63	99.00%
ELF_hash	10240	47198	16	4.63	99.00%
BKDR_hash	10240	47198	16	4.63	99.00%
SDBM_hash	10240	47198	16	4.63	98.90%
DJB_hash	10240	47198	15	4.64	98.85%
AP_hash	10240	47198	16	4.63	98.96%
CRC_hash	10240	47198	16	4.64	98.77%

所以实际应用中我们可以随便的选取，本文针对ELFhash

 

3.原理：

首先，我们在开始之前需要明确几点

1.unsigned int有4个字节，32个比特位

2.异或操作中0是单位元，任何数与1异或相当于取反

3.unsigned无符号类型的数据右移操作均是执行逻辑右移（左高位自动补0）

4.ELFhash算法的核心在于“影响“

 

先附上代码：

1. unsigned int ELFhash(char *str)
2. {
3. unsigned int hash=0;
4. unsigned int x=0;
5. while(*str)
6. {
7. hash=(hash<<4)+*str; //1
8. if((x=hash & 0xf0000000)!=0) //2
9. {
10. hash^=(x>>24); //影响5-8位，杂糅一次 3
11. hash&=~x; //清空高四位 4
12. }
13. str++; //5
14. }
15. return (hash & 0x7fffffff); //6
16. }

解释：

首先我们的hash结果是一个unsigned int类型的数据：

0000 0000 0000 0000

1.hash左移4位，将str插入（一个char有八位）这里我开始也一直是怀疑的态度，那么第一个字节的高四位不就乱了吗

实际上这也是我们的第一次杂糅，我们是故意这么做的，这里我们需要注意标记一下，我们在第一个字节的高四位做了第一次杂糅

2.x这里用0xf0000000获取了hash的第四个字节的高四位，并用高四位作为掩码做第二次杂糅

在这里我们首先声明一下，因为我们的ELFhash强调的是每个字符都要对最后的结构有影响，所以说我们左移到一定程度是会吞掉最高的四位的，所以说我们要将最高的四位先对串产生影响，再让他被吞掉，之后的所有的影响都是叠加的，这就是多次的杂糅保证散列均匀，防止出现冲突的大量出现

3.x掩码右移24位移动到刚才的5-8位哪里在对5-8位进行第二次杂糅

4.我们定时清空高四位，实际上这部操作我们完全没有必要，但是算法要求，因为我们下一次的左移会自动吞掉这四位//这里存疑，不会减少我们的hash的范围？

5.str递增，引入下一个字符进行杂糅

6.返回一个缺失了最高符号位的无符号数（为了之后防止用到了有符号的时候造成的溢出）作为最后的hash值

 

4.Code:

1. /*#include"iostream"
2. #include"cstdio"
3. #include"cstring"
4.  
5. using namespace std;
6.  
7. unsigned int a=0x80;
8.  
9. int main()
10. {
11. printf("%d ",a>>1); //无符号数实行逻辑右移
12. return 0;
13. } */
14.  
15. #include"iostream"
16. #include"cstdio"
17. #include"cstring"
18.  
19. using namespace std;
20.  
21. unsigned int ELFhash(char *str)
22. {
23. unsigned int hash=0;
24. unsigned int x=0;
25. while(*str)
26. {
27. hash=(hash<<4)+*str;
28. if((x=hash & 0xf0000000)!=0)
29. {
30. hash^=(x>>24); //影响5-8位，杂糅一次
31. hash&=~x; //清空高四位
32. }
33. str++;
34. }
35. return (hash & 0x7fffffff);
36. }
37.  
38. int main()
39. {
40. char data[100];
41. memset(data,0,sizeof(data));
42. scanf("%s",data);
43. printf("%d ",ELFhash(data));
44. return 0;
45. }

最后，按照我的思路来看的话，ELFhash最多可以散列的空间的大小是几个亿的数据？如果去掉hash&=~x这一句的话会不会扩大我们hash的范围，尽可能利用空间，我下星期问问数据结构老师好了！

5.应用：

我们在对内存地址的进行的操作的时候，可以将数据的内存地址进行哈希

因为每个数据的内存地址都是唯一的，所以我们只需要一步获取内存地址的十六进制的表示就可以了

语句是

sprintf(data,"%0x",&now_data);

第一个data保存我们的保留字符串的内存空间（字符串数组）

中间的是保存的进制的形式

最后是我们的要取地址的内存空间
利用这种思路，我们可以很清晰明了的对链表相交的问题构建一种新的解法，我们采用哈希我们的内存空间就可以了，可以再O(n)中完成查找