逐步实现hash算法（基于BKDRhash函数）

哈希(Hash)算法,即散列函数。它是一种单向密码体制,即它是一个从明文到密文的不可逆的映射,只有加密过程,没有解密过程。同时,哈希函数可以将任意长度的输入经过变化以后得到固定长度的输出。hash算法一般用于快速查找和加密。

hash算法可以使用的哈希函数种类很多，处理冲突的方法也有开放定址、再哈希、链地址、公共溢出区等。

因此，在编写代码之前，首先需要根据所要处理的数据，选择合适的hash函数和冲突处理办法。开放定址需要空闲存储单元，所需要的表比实际容量大，而且容易产生二次聚集发生新冲突。链地址使用链表存储关键字，可以随时插入新数据，数据量大小不受限制。缺点是要用到指针，给新单元分配地址需要时间，会一定程度上减慢算法速度，但影响不大可以忽略。

笔者需要处理的是一个10W行字符串的字典，关键字重复率高。因此选择适用于字符串的哈希函数，常用字符串哈希函数有 BKDRHash,APHash,DJBHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash等，个人倾向于BKDRHash，记忆和使用都很简便。

BKDRHash函数代码如下：

 1 unsigned int BKDRhash(TYPE key)
 2 {//BKDRhash函数
 3     unsigned int seed = 131;
 4     unsigned int hash = 0;
 5
 6     while(*key != ‘\n‘ && *key != 0)      //通常使用时，判别条件为*key != 0即可，此处的*key != ‘\n‘是因笔者程序需要
 7         hash = hash * seed + (*key++);
 8
 9     return hash % DICLEN;
10 }

对于关键字重复的冲突处理方法，笔者这里使用链地址法。hash表结构体如下：

 1 #define STRLEN 15
 2 #define DICLEN 100000
 3
 4 typedef char* TYPE;
 5 typedef int BOOL;
 6
 7 typedef struct _NODE{
 8     TYPE data;
 9     struct _NODE* next;
10 }NODE;
11
12 typedef struct _HASH_TABLE{
13     NODE* phead;           //此变量可以不用，这里使用是为了减少其他函数中的重新定义过程
14     NODE** chainhash;
15 }HASH_TABLE;

准备工作OK，整理好思路，可以开始编写hash算法了。O(∩_∩)O

首先，创建一个hash表，并对哈希表，链表，头节点进行初始化。

 1 NODE* create_node()
 2 {//开辟节点
 3     NODE* pnode = (NODE*)malloc(sizeof(NODE));
 4     memset(pnode, 0, sizeof(NODE));
 5
 6     pnode->data = (char*)malloc(STRLEN * sizeof(char));
 7     memset(pnode->data, 0, STRLEN * sizeof(char));
 8     pnode->next = NULL;
 9
10     return pnode;
11 }
12
13 HASH_TABLE* create_hash()
14 {//创建hash表
15     HASH_TABLE* new_hash_table = (HASH_TABLE*)malloc(sizeof(HASH_TABLE));
16     memset(new_hash_table, 0, sizeof(HASH_TABLE));
17
18     new_hash_table->phead = create_node();
19     new_hash_table->chainhash = (NODE**)malloc(DICLEN * sizeof(NODE*));
20
21     for(int i = 0; i < DICLEN; i++){
22         new_hash_table->chainhash[i] = (NODE*)malloc(sizeof(NODE));
23         memset(new_hash_table->chainhash[i], 0, sizeof(NODE));
24     }
25
26     return new_hash_table;
27 }

插入数据

链表的chainhash每个分量的初始状态都是空指针，凡是哈希函数值 BKDRhash(data)相同的记录，都插入同一个链表chainhash[i]，此时i = BKDRhash(data)。该链表头结点不为空的话，指针就后移，在表尾插入新记录（表头、表尾插入均可，只要保持每次操作相同，即同一链表中的关键字有序）。

 1 BOOL insert_data(HASH_TABLE* hash, NODE* phead, TYPE data)
 2 {//插入新数据
 3     if(hash == NULL)
 4         return 0;
 5
 6     if(hash->chainhash[BKDRhash(data)]->data == NULL){
 7         NODE* newnode = create_node();
 8
 9         strcpy(newnode->data, data);
10         newnode->next = NULL;
11         hash->chainhash[BKDRhash(data)]->data = newnode->data;
12         hash->chainhash[BKDRhash(data)]->next = newnode->next;
13
14         free(newnode);
15         return 1;
16     }
17
18     else{
19         phead = hash->chainhash[BKDRhash(data)];
20
21         while(phead->next != NULL)
22             phead = phead->next;
23
24         phead->next = create_node();
25
26         strcpy(phead->next->data, data);
27         phead->next->next = NULL;
28
29         return 1;
30     }
31 }

查找数据

查找数据时，首先通过哈希函数值找到对应的链表，然后比较字符串内容。

 1 NODE* find_data(HASH_TABLE* hash, NODE* phead, TYPE data)
 2 {//查找数据
 3     phead = hash->chainhash[BKDRhash(data)];
 4
 5     if(hash == NULL)
 6         return NULL;
 7
 8     while(phead != NULL){
 9
10         if(strncmp(phead->data, data, STRLEN) == 0)
11             return phead;
12         else
13             phead = phead->next;
14     }
15
16     return NULL;
17 }

删除数据

删除数据类似于单链表的删除操作

 1 BOOL del_data(HASH_TABLE* hash, NODE* phead, TYPE data)
 2 {//删除数据
 3
 4     phead->next = create_node();
 5     phead->next = hash->chainhash[BKDRhash(data)];
 6
 7     if(hash == NULL)
 8         return 0;
 9
10     while(phead->next != NULL){
11
12         if(strncmp(phead->next->data, data, STRLEN) == 0){
13
14             if(phead->next->data == hash->chainhash[BKDRhash(data)]->data)
15                 hash->chainhash[BKDRhash(data)] = phead->next->next;
16             else
17                 phead->next = phead->next->next;
18
19             return 1;
20         }
21         else
22             phead->next = phead->next->next;
23     }
24
25     free(phead->next);
26
27     return 0;
28 }

修改数据

修改数据非常简单，即先删除后插入

 1 BOOL alter_data(HASH_TABLE* hash, NODE* phead, TYPE data, TYPE new_data)
 2 {//修改数据
 3     if(hash == NULL)
 4         return 0;
 5
 6     if(data == new_data)
 7         return 1;
 8
 9     if(del_data(hash, phead, data) == 1){
10
11         if(insert_data(hash, phead, new_data) == 1)
12             return 1;
13         else
14             return 0;
15     }
16
17     else
18         return 0;
19 }

这样，一个简单的hash算法就写好了！笔者冗长的测试代码如下。。。。至于为什么测试要写这么长，笔者也不造o(╯□╰)o

测试用10W行字典：

http://yunpan.cn/Q7BBIXwd3uTYe  访问密码 8889

 1 int main(int argc, char* argv[])
 2 {//测试
 3     int i = 0;
 4     char* testdata = "kyxntghcxolgqlw\n";
 5     char data[STRLEN + 2] = {0};
 6
 7     HASH_TABLE* dic = create_hash();
 8
 9     FILE* fp = fopen("dic.txt", "r+");
10     assert(fp != 0);
11
12     while(i < DICLEN){
13         fgets(data, STRLEN + 2, fp);
14         insert_data(dic, dic->phead, data);
15         i++;
16     }
17
18     //查找测试
19     if(find_data(dic, dic->phead, testdata) != NULL)
20         printf("find it: %s\n", (find_data(dic, dic->phead, testdata))->data);
21     else
22         printf("no this data!\n");
23
24     //删除再查找测试
25     if(del_data(dic, dic->phead, testdata) == 1)
26         printf("delete it!\n");
27     else
28         printf("try again!\n");
29
30     if(find_data(dic, dic->phead, testdata) != NULL)
31         printf("find it: %s\n", (find_data(dic, dic->phead, testdata))->data);
32     else
33         printf("no this data!\n");
34
35     //修改数据测试
36     testdata = "fpwdwpk";
37     char* newdata = "bibibibibiu\n";
38
39     if(alter_data(dic, dic->phead, testdata, newdata) == 1){
40
41         if(find_data(dic, dic->phead, newdata) != NULL)
42             printf("find it: %s\n", (find_data(dic, dic->phead, newdata))->data);
43         else
44             printf("no this data!\n");
45     }
46
47     fclose(fp);
48     free(dic);
49
50     return 0;
51 }

欢迎转载，请备注原始连接http://www.cnblogs.com/liuliuliu/p/3966851.html，并注明转载。

作者bibibi_liuliu，联系方式[email protected]

时间： 2024-12-05 08:05:44

逐步实现hash算法（基于BKDRhash函数）的相关文章

常见hash算法的原理（转）

常见hash算法的原理 散列表,它是基于快速存取的角度设计的,也是一种典型的“空间换时间”的做法.顾名思义,该数据结构可以理解为一个线性表,但是其中的元素不是紧密排列的,而是可能存在空隙. 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度.这个映射函数叫做散列函数,存放记录的数组叫做散列表. 比如我们存储70个元素,但我们可能为这70个元素申请了100个元素的空间.7

常见hash算法的原理

转自:http://blog.csdn.net/zxycode007/article/details/6999984 散列表,它是基于快速存取的角度设计的,也是一种典型的“空间换时间”的做法.顾名思义,该数据结构可以理解为一个线性表,但是其中的元素不是紧密排列的,而是可能存在空隙. 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度.这个映射函数叫做散列函数,存放记录的

linux内核netfilter连接跟踪的hash算法

linux内核中的netfilter是一款强大的基于状态的防火墙,具有连接跟踪(conntrack)的实现.conntrack是netfilter的核心,许多增强的功能,例如,地址转换(NAT),基于内容的业务识别(l7, layer-7 module)都是基于连接跟踪.然而,netfilter的性能还有很多值得改进的地方. netfilter的连接跟踪的hash算法是在Bob Jenkins的lookup2.c基础上的改进实现,Bob Jenkins已经推出lookup3.c的实现,见地址:h

转： memcached Java客户端spymemcached的一致性Hash算法

转自:http://colobu.com/2015/04/13/consistent-hash-algorithm-in-java-memcached-client/ memcached Java客户端spymemcached的一致性Hash算法 最近看到两篇文章,一个是江南白衣的陌生但默默一统江湖的MurmurHash,另外一篇是张洋的一致性哈希算法及其在分布式系统中的应用.虽然我在项目中使用memcached的java客户端spymemcached好几年了,但是对它的一致性哈希算法的细节从来

hash算法总结收集

hash算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键值可以对应多个真实值),这样可以快速在数组等条件中里面存取数据.     在网上看了不少HASH资料,所以对HASH的相关资料进行总结和收集.   //HashTable.h template class HashTable{ public : HashTable( int count ) ; void put( T* t ,int key ) ; T* get

一致性hash算法简介与代码实现

一.简介: 一致性hash算法提出了在动态变化的Cache环境中,判定哈希算法好坏的四个定义: 1.平衡性(Balance) 2.单调性(Monotonicity) 3.分散性(Spread) 4.负载(Load) 普通的哈希算法(也称硬哈希)采用简单取模的方式,将机器进行散列,这在cache环境不变的情况下能取得让人满意的结果,但是当cache环境动态变化时,这种静态取模的方式显然就不满足单调性的要求(当增加或减少一台机子时,几乎所有的存储内容都要被重新散列到别的缓冲区中). 一致性哈希算法的

[转]海量数据解决思路之Hash算法

一.概述 本文将粗略讲述一下Hash算法的概念特性,里边会结合分布式系统负载均衡实例对Hash的一致性做深入探讨.另外,探讨一下Hash算法在海量数据处理方案中的通用性.最后,从源代码出发,具体分析一下Hash算法在MapReduce框架的中的应用. 二.Hash算法 Hash可以通过散列函数将任意长度的输入变成固定长度的输出,也可以将不同的输入映射成为相同的相同的输出,而且这些输出范围也是可控制的,所以起到了很好的压缩映射和等价映射功能.这些特性被应用到了信息安全领域中加密算法,其中等价映射这

Hash算法的讲解

散列表,又叫哈希表,它是基于快速存取的角度设计的,也是一种典型的“空间换时间”的做法.顾名思义,该数据结构可以理解为一个线性表,但是其中的元素不是紧密排列的,而是可能存在空隙. 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度.这个映射函数叫做散列函数,存放记录的数组叫做散列表.比如我们存储70个元素,但我们可能为这70个元素申请了100个元素的空间.70/100=0

1.3.1 区块链中的加密算法——Hash算法（更新）

为了为保证存储于区块链中的信息的安全与完整,区块链中使用了包含密码哈希函数和椭圆曲线公钥密码技术在内的大量的现代密码学技术,同时,这些密码学技术也被用于设计基于工作量证明的共识算法并识别用户. 在前边的文章中已经系统的讲述了密码学中的哈希算法,在本节,将会给大家介绍Hash算法在区块链中的应用! 概念回顾: 哈希函数:是一类数学函数,可以在有限合理的时间内,将任意长度的消息压缩为固定长度的二进制串,其输出值称为哈希值,也称为散列值. 以哈希函数为基础构造的哈希算法,在现代密码学中扮演着重要的角色