HASH表的实现（拉链法） - C/C++

本文的一些基本概念参考了一部分百度百科，当然只保留了最有价值的部分，代码部分完全是自己实现！

简介

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。它通过把关键码值映射到表中一个位置来访问记录，有点类似于数组，并且能在O(1)（冲突情况另算）下查找到元素。

 

基本概念

设所有可能出现的关键字集合记为u(简称全集)。实际发生(即实际存储)的关键字集合记为k（|k|比|u|小得多）。|k|是集合k中元素的个数。
散列方法是使用函数hash将u映射到表t[0..m-1]的下标上（m=o(|u|)）。这样以u中关键字为自变量，以h为函数的运算结果就是相应结点的存储地址。从而达到在o(1)时间内就可完成查找。

其中：

① hash：u→{0，1，2，…，m-1} ，通常称h为散列函数(hash function)。散列函数h的作用是压缩待处理的下标范围，使待处理的|u|个值减少到m个值，从而降低空间开销。
② t为散列表(hash table)。
③ hash(ki)(ki∈u)是关键字为ki结点存储地址(亦称散列值或散列地址)。
④ 将结点按其关键字的散列地址存储到散列表中的过程称为散列(hashing).
 
比如：有一组数据包括用户名字、电话、住址等，为了快速的检索，我们可以利用名字作为关键码，hash规则就是把名字中每一个字的拼音的第一个字母拿出来，把该字母在26个字母中的顺序值取出来加在一块作为该记录的地址。比如张三，就是z+s=26+19=45。就是把张三存在地址为45处。

但是这样存在一个问题，比如假如有个用户名字叫做：周四，那么计算它的地址时也是z+s=45，这样它与张三就有相同的地址，这就是冲突，也叫作碰撞(hash碰撞)。
冲突：两个不同的关键字，由于散列函数值相同，因而被映射到同一表位置上。该现象称为冲突(collision)或碰撞。发生冲突的两个关键字称为该散列函数的同义词(synonym)。

构造方法

散列函数的选择有两条标准：简单和均匀简单指散列函数的计算简单快速；
均匀指对于关键字集合中的任一关键字，散列函数能以等概率将其映射到表空间的任何一个位置上。也就是说，散列函数能将子集k随机均匀地分布在表的地址集{0，1，…，m-1}上，以使冲突最小化。

常用散列函数

（1）直接定址法：比如在一个0～100岁的年龄统计表，我们就可以把年龄作为地址。

（2）平方取中法
具体方法：先通过求关键字的平方值扩大相近数的差别，然后根据表长度取中间的几位数作为散列函数值。又因为一个乘积的中间几位数和乘数的每一位都相关，所以由此产生的散列地址较为均匀。
（3）除留余数法
取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。该方法的关键是选取p。选取的p应使得散列函数值尽可能与关键字的各位相关。p最好为素数。
（4）随机数法
选择一个随机函数，取关键字的随机函数值为它的散列地址，即
h(key)=random(key)
其中random为伪随机函数，但要保证函数值是在0到m-1之间。
处理冲突
处理冲突——假设哈希表的地址集为0~n-1,冲突是指由关键字得到的哈希 地址为j(0<=j<=n-1)的位置上已存有记录,则“处理冲突”就是为该关键字的记录找到另一个“空”的哈希地址.
在处理冲突过程中可能得到一个地址序列Hi (i=1,2,…,k),即在处理哈希地址的冲突时,若得到的另一个哈希地址H1仍然发生冲突,则再求下一个地址 H2,若H2仍然冲突,再求得H3.依次类推,直到Hk不发生冲突为止,则Hk为记录在表中的地址.

另外，理想的散列函数满足下面几点：

1、散列函数的输出值尽量接近均匀分布；

2、x的微小变化可以使f(x)发生非常大的变化，即所谓“雪崩效应”(Avalanche effect)；

处理冲突的方法

(1)开放定址法(2)拉链法 (3)建立公共溢出区法
拉链法解决冲突的做法是：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组t[0..m-1]。凡是散列地址为i的结点，均插入到以t为头指针的单链表中。t中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于1，但一般均取α≤1。

 

下面是代码实现，已经测试过：

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct node{
    char *name;//字段名
    char *desc;//描述
    struct node *next;
}node;

#define HASHSIZE 100 //hash表长度
static node* hashtable[HASHSIZE];//定义一个hash数组，该数组的每个元素是一个hash结点指针,并且由于是全局静态变量,默认初始化为NULL

unsigned int hash(char *s)
{//哈希函数
    unsigned int h=0;
    for(;*s;s++)
        h=*s+h*31;//将整个字符串按照特定关系转化为一个整数，然后对hash长度取余
    return h%HASHSIZE;
}

node* lookup(char *str)
{
    unsigned int hashvalue = hash(str);
    node* np = hashtable[hashvalue];
    for( ; np!=NULL; np = np->next)
    {//这里是链地址法解决的冲突,返回的是第一个链表结点
        if(!strcmp(np->name, str))//strcmp相等的时候才返回0
            return np;
    }
    return NULL;
}

char* search(char* name)
{//对hash表查找特定元素(元素是字符串）
    node* np=lookup(name);
    if(np==NULL)
        return NULL;
    else
        return np->desc;
}

node* malloc_node(char* name, char* desc)
{//在堆上为结点分配内存，并填充结点
    node *np=(node*)malloc(sizeof(node));
    if(np == NULL)
        return NULL;
    np->name = name;
    np->desc = desc;
    np->next = NULL;
    return np;
}

int insert(char* name, char* desc)
{
    unsigned int hashvalue;
    hashvalue = hash(name);
    //头插法，不管该hash位置有没有其他结点，直接插入结点
    node* np = malloc_node(name, desc);
    if (np == NULL) return 0;//分配结点没有成功，则直接返回
    np->next = hashtable[hashvalue];
    hashtable[hashvalue] = np;
    return 1;
}

/* A pretty useless but good debugging function,
which simply displays the hashtable in (key.value) pairs
*/
void displayHashTable()
{//显示hash表元素（不包括空）
    node *np;
    unsigned int hashvalue;
    for(int i=0; i < HASHSIZE; ++i)
    {
        if(hashtable[i] != NULL)
        {
            np = hashtable[i];
            printf("\nhashvalue: %d (", i);
            for(; np != NULL; np=np->next)
                printf(" (%s.%s) ", np->name, np->desc);
            printf(")\n");
        }
    }
}

void cleanUp()
{//清空hash表
    node *np,*tmp;
    for(int i=0;i < HASHSIZE; ++i)
    {
        if(hashtable[i] != NULL)
        {
            np = hashtable[i];
            while(np != NULL)
            {
                tmp = np->next;
                //free(np->name);
                //free(np->desc);
                free(np);
                np = tmp;
            }
        }
    }
}

int main()
{
    char* names[]={"First Name","Last Name","address","phone","k101","k110"};
    char* descs[]={"Kobe","Bryant","USA","26300788","Value1","Value2"};
    
    for(int i=0; i < 6; ++i)
        insert(names[i], descs[i]);
    printf("we should see %s\n",search("k110"));
    insert("phone","9433120451");//这里计算的hash是冲突的，为了测试冲突情况下的插入
     printf("we have %s and %s\n",search("k101"),search("phone"));
    displayHashTable();
    cleanUp();
    return 0;
}

输出结果：

需要特别注意一下，上面的hash函数计算为29的，用的就是单链表的头插法来解决冲突，不要复杂化了问题！

上面的代码是我自己实现的拉链法版本，后面我还会继续增加一些其他更好的版本，Waiting！

环境：amd64  系统：gentoo  编译器：gcc version 4.5.3 (Gentoo 4.5.3-r2 p1.5, pie-0.4.7) 

这是一个数据结构课程设计的作品....

</pre><pre name="code" class="cpp">/*
*哈希表 除留余数 拉链法
*/
#include<stdio.h>
#include<stdlib.h>

#define TableSize 71

typedef unsigned int Index;

typedef struct ListNode
{
	char element[20];
	struct ListNode *next;
}*Position;

typedef struct HashTbl
{
	int TblSize;
	 Position *TheLists;
	//struct  HashTbl *next;
}*HashTable;

void InitializeTable(HashTable Tbl[])
{
	int i;
	HashTable tmp;
	for(i=0;i<TableSize;i++)
	{
		tmp=(HashTable)malloc(sizeof(struct HashTbl)); 
		Tbl[i]=tmp;
		Tbl[i]->TblSize=TableSize;
		Tbl[i]->TheLists=NULL;
	}
}

Index Hash(char Key[])
{
	int i=0;
	int b=0;
	while(Key[i]!='\0' )
	{
		b+=(((int)Key[i])*((int)Key[i]));
		i++;
	}//这段用于获取key值，可以根据自己要求修改
	return b%TableSize;
	//除留余数法。。。
}

void Insert(HashTable Tbl[])
{
	//printf("acftion1\n");
	Position p,newnode;
	newnode=(Position)malloc(sizeof(struct ListNode));
	int i=0;
	char k[20];
	Index key;
		scanf("%s",k);
		key=Hash(k);
		//printf("%d\n",key);
		while(k[i]!='\0' )
		{
			newnode->element[i]=k[i];
			i++;
		}
		newnode->next=NULL;
		//printf("%s\n",newnode->element);
	
		p=Tbl[key]->TheLists;
		if(!p)
			Tbl[key]->TheLists=newnode;
		while(p)
		{	
			//printf("%s\n",p->element);
			if(p->next==NULL)
			{
				p->next=newnode;
				//printf("OK!");
				return ;
			}
			else
				p=p->next;
		}
}

void Print(HashTable Tbl[])
{
	int i,j,k,l,m;
	k=0;
	l=0;
	m=0;
	double n,o;
	Position p;
	for(i=0;i<TableSize;i++)
	{
		j=0;
		p=Tbl[i]->TheLists;
		while(p)
		{
			printf("%d->%d->%-20s\t",i,j,p->element);
			p=p->next;
			k++;	//统计输出次数，既是数据记录集的总个数
			j++;	//同一位置上的输出个数，当i＋1是要清零
			m+=j;
			
			
		}
		
		if(!j)
			printf("%d->%d->\t",i,j);
		else
			j--;
		l+=j;		//计算冲突的记录
		
		//printf("\t%d",j);
		printf("\n");
		
	}
	n=(double)l/(double)k;	o=(double)m/(double)k;
	//k为输入记录的总数， l为冲突的记录的总个数  m统计每一个记录的查找长度。
	//n为冲突率， o为平均查找长度。
	printf("**********\t%d\t%d\t%d\n",k,l,m);
	printf("**********\tConflict:%lf\tASL:%lf\n",n,o);
}

void  Search(HashTable Tbl[])
{
	Position p;
	char k[20];
	Index key;
	int j;
	
	scanf("%s",k);
	key=Hash(k);printf("%d\n",key);
	p=Tbl[key]->TheLists;
	if(p)
	{
	while(strcmp(p->element,k))
	{
		p=p->next;
		if(!p)
		{
			printf("No Item found!\n");
			return ;
		}
		j++;
	}
	printf("%d->%d->%s\n",key,j,p->element);
	}
	else
	{
		printf("No Item found!\n");
	}
}

void Destroy(HashTable Tbl[])  
{  
	int i;
	Position p;  
	Position temp;
	
	for(i=TableSize-1;i>=0;i--)  
	{
		//printf("%d\n",i);
		p=Tbl[i]->TheLists;
		while(p!=NULL)  
		{  
			temp=p->next;  
			free(p);  
			p=temp;  
		}
		free(Tbl[i]);  
	}
}

int main()
{
	HashTable T[TableSize];
	InitializeTable(T);
	int a,i;
	while(1)
	{
		
		printf("*******1.Insert data**********\n");
		printf("*******2.search data*********\n");
		printf("*******3.show add ***********\n");
		printf("*******4.exit*******************\n");
		printf("switich action:	");
		scanf("%d",&a);
		switch(a)
		{
			case 1:
			 	Insert(T);
			 	break;
			 
			case 2:
				Search(T);
			 	break;
			  
			case 3:
				Print(T);
				break;
			 
			case 4:
				Destroy(T);
				return ;
				break;
			 
			default:
				printf("Err! please check!\n");
				break;
		}
	}
	return 0;
}