哈希表算法的编写

哈希算法的编写

hash表，有时候也被称为散列表。个人认为，hash表是介于链表和二叉树之间的一种中间结构。链表使用十分方便，但是数据查找十分麻烦；二叉树中的数据严格有序，但是这是以多一个指针作为代价的结果。hash表既满足了数据的查找方便，同时不占用太多的内容空间，使用也十分方便。

    打个比方来说，所有的数据就好像许许多多的书本。如果这些书本是一本一本堆起来的，就好像链表或者线性表一样，整个数据会显得非常的无序和凌乱，在你找到自己需要的书之前，你要经历许多的查询过程；而如果你对所有的书本进行编号，并且把这些书本按次序进行排列的话，那么如果你要寻找的书本编号是n，那么经过二分查找，你很快就会找到自己需要的书本；但是如果你每一个种类的书本都不是很多，那么你就可以对这些书本进行归类，哪些是文学类，哪些是艺术类，哪些是工科的，哪些是理科的，你只要对这些书本进行简单的归类，那么寻找一本书也会变得非常简单，比如说如果你要找的书是计算机方面的书，那么你就会到工科一类当中去寻找，这样查找起来也会显得麻烦。

    不知道这样举例你清楚了没有，上面提到的归类方法其实就是hash表的本质。下面我们可以写一个简单的hash操作代码。

    a）定义hash表和基本数据节点

[cpp] view plaincopy

1. typedef struct _NODE 
2. { 
3.     int data; 
4.     struct _NODE* next; 
5. }NODE; 
6.  
7. typedef struct _HASH_TABLE 
8. { 
9.     NODE* value[10]; 
10. }HASH_TABLE; 

[cpp] view plain copy

1. typedef struct _NODE  
2. {  
3.     int data;  
4.     struct _NODE* next;  
5. }NODE;  
6.   
7. typedef struct _HASH_TABLE  
8. {  
9.     NODE* value[10];  
10. }HASH_TABLE;  

    b）创建hash表

[cpp] view plaincopy

1. HASH_TABLE* create_hash_table() 
2. { 
3.     HASH_TABLE* pHashTbl = (HASH_TABLE*)malloc(sizeof(HASH_TABLE)); 
4.     memset(pHashTbl, 0, sizeof(HASH_TABLE)); 
5.     return pHashTbl; 
6. } 

[cpp] view plain copy

1. HASH_TABLE* create_hash_table()  
2. {  
3.     HASH_TABLE* pHashTbl = (HASH_TABLE*)malloc(sizeof(HASH_TABLE));  
4.     memset(pHashTbl, 0, sizeof(HASH_TABLE));  
5.     return pHashTbl;  
6. }  

    c）在hash表当中寻找数据

[cpp] view plaincopy

1. NODE* find_data_in_hash(HASH_TABLE* pHashTbl, int data) 
2. { 
3.     NODE* pNode; 
4.     if(NULL ==  pHashTbl) 
5.         return NULL; 
6.  
7.     if(NULL == (pNode = pHashTbl->value[data % 10])) 
8.         return NULL; 
9.  
10.     while(pNode){ 
11.         if(data == pNode->data) 
12.             return pNode; 
13.         pNode = pNode->next; 
14.     } 
15.     return NULL; 
16. } 

[cpp] view plain copy

1. NODE* find_data_in_hash(HASH_TABLE* pHashTbl, int data)  
2. {  
3.     NODE* pNode;  
4.     if(NULL ==  pHashTbl)  
5.         return NULL;  
6.   
7.     if(NULL == (pNode = pHashTbl->value[data % 10]))  
8.         return NULL;  
9.   
10.     while(pNode){  
11.         if(data == pNode->data)  
12.             return pNode;  
13.         pNode = pNode->next;  
14.     }  
15.     return NULL;  
16. }  

    d）在hash表当中插入数据

[cpp] view plaincopy

1. STATUS insert_data_into_hash(HASH_TABLE* pHashTbl, int data) 
2. { 
3.     NODE* pNode; 
4.     if(NULL == pHashTbl) 
5.         return FALSE; 
6.  
7.     if(NULL == pHashTbl->value[data % 10]){ 
8.         pNode = (NODE*)malloc(sizeof(NODE)); 
9.         memset(pNode, 0, sizeof(NODE)); 
10.         pNode->data = data; 
11.         pHashTbl->value[data % 10] = pNode; 
12.         return TRUE; 
13.     } 
14.  
15.     if(NULL != find_data_in_hash(pHashTbl, data)) 
16.         return FALSE; 
17.  
18.     pNode = pHashTbl->value[data % 10]; 
19.     while(NULL != pNode->next) 
20.         pNode = pNode->next; 
21.  
22.     pNode->next = (NODE*)malloc(sizeof(NODE)); 
23.     memset(pNode->next, 0, sizeof(NODE)); 
24.     pNode->next->data = data; 
25.     return TRUE; 
26. } 

[cpp] view plain copy

1. STATUS insert_data_into_hash(HASH_TABLE* pHashTbl, int data)  
2. {  
3.     NODE* pNode;  
4.     if(NULL == pHashTbl)  
5.         return FALSE;  
6.   
7.     if(NULL == pHashTbl->value[data % 10]){  
8.         pNode = (NODE*)malloc(sizeof(NODE));  
9.         memset(pNode, 0, sizeof(NODE));  
10.         pNode->data = data;  
11.         pHashTbl->value[data % 10] = pNode;  
12.         return TRUE;  
13.     }  
14.   
15.     if(NULL != find_data_in_hash(pHashTbl, data))  
16.         return FALSE;  
17.   
18.     pNode = pHashTbl->value[data % 10];  
19.     while(NULL != pNode->next)  
20.         pNode = pNode->next;  
21.   
22.     pNode->next = (NODE*)malloc(sizeof(NODE));  
23.     memset(pNode->next, 0, sizeof(NODE));  
24.     pNode->next->data = data;  
25.     return TRUE;  
26. }  

    e）从hash表中删除数据

[cpp] view plaincopy

1. STATUS delete_data_from_hash(HASH_TABLE* pHashTbl, int data) 
2. { 
3.     NODE* pHead; 
4.     NODE* pNode; 
5.     if(NULL == pHashTbl || NULL == pHashTbl->value[data % 10]) 
6.         return FALSE; 
7.  
8.     if(NULL == (pNode = find_data_in_hash(pHashTbl, data))) 
9.         return FALSE; 
10.  
11.     if(pNode == pHashTbl->value[data % 10]){ 
12.         pHashTbl->value[data % 10] = pNode->next; 
13.         goto final; 
14.     } 
15.  
16.     pHead = pHashTbl->value[data % 10]; 
17.     while(pNode != pHead ->next) 
18.         pHead = pHead->next; 
19.     pHead->next = pNode->next; 
20.  
21. final: 
22.     free(pNode); 
23.     return TRUE; 
24. } 

[cpp] view plain copy

1. STATUS delete_data_from_hash(HASH_TABLE* pHashTbl, int data)  
2. {  
3.     NODE* pHead;  
4.     NODE* pNode;  
5.     if(NULL == pHashTbl || NULL == pHashTbl->value[data % 10])  
6.         return FALSE;  
7.   
8.     if(NULL == (pNode = find_data_in_hash(pHashTbl, data)))  
9.         return FALSE;  
10.   
11.     if(pNode == pHashTbl->value[data % 10]){  
12.         pHashTbl->value[data % 10] = pNode->next;  
13.         goto final;  
14.     }  
15.   
16.     pHead = pHashTbl->value[data % 10];  
17.     while(pNode != pHead ->next)  
18.         pHead = pHead->next;  
19.     pHead->next = pNode->next;  
20.   
21. final:  
22.     free(pNode);  
23.     return TRUE;  
24. }  

总结：

    1、hash表不复杂，我们在开发中也经常使用，建议朋友们好好掌握；

    2、hash表可以和二叉树形成复合结构，至于为什么，建议朋友们好好思考一下？

哈希表算法-哈希表的实际应用

以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢?

大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是点对点的意思的软件）， 它采用了"多源文件传输协议”（MFTP，the Multisource FileTransfer Protocol）。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。

什么是文件的hash值呢?

MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。

当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息，然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了，这个文件当前所在的用户的地址，端口等信息，这样emule就知道到哪里去下载了。

一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。

对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。

那么什么是userhash呢?

道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。

那么什么是hash文件呢?

我们经常在emule日志里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，目前在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。

关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。

一般的线性表、树中，记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。因而查找时，只需根据这个对应关系f找到给定值K的像f(K）。若结构中存在关键字和K相等的记录，则必定在f(K）的存储位置上，由此不需要进行比较便可直接取得所查记录。在此，称这个对应关系f为哈希函数，按这个思想建立的表为哈希表（又称为杂凑法或散列表）。

哈希表不可避免冲突（collision）现象：对不同的关键字可能得到同一哈希地址 即key1≠key2，而hash(key1)=hash(key2）。具有相同函数值的关键字对该哈希函数来说称为同义词（synonym）。因此，在建造哈希表时不仅要设定一个好的哈希函数，而且要设定一种处理冲突的方法。可如下描述哈希表：根据设定的哈希函数H(key）和所选中的处理冲突的方法，将一组关键字映象到一个有限的、地址连续的地址集（区间）上并以关键字在地址集中的“象”作为相应记录在表中的存储位置，这种表被称为哈希表。

对于动态查找表而言，1) 表长不确定；2）在设计查找表时，只知道关键字所属范围，而不知道确切的关键字。因此，一般情况需建立一个函数关系，以f(key）作为关键字为key的录在表中的位置，通常称这个函数f(key）为哈希函数。（注意：这个函数并不一定是数学函数）

哈希函数是一个映象，即：将关键字的集合映射到某个地址集合上，它的设置很灵活，只要这个地址集合的大小不超出允许范围即可。

现实中哈希函数是需要构造的，并且构造的好才能使用的好。

用途：加密，解决冲突问题。

用途很广，比特精灵中就使用了哈希函数，你可以自己看看。