哈希表

#include "stdio.h"
#include "stdlib.h"

#define SUCCESS 1
#define UNSUCCESS 0
#define DUPLICATE -1
#define OK 1
#define ERROR -1
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)< (b))
#define LQ(a,b) ((a)<=(b))
#define BT(a,b) ((a)> (b))
#define NULLKEY -111

int hashsize[]={11,19,29,37}; // 哈希表容量递增表，
//一个合适的素数序列

int m=0; // 哈希表表长，全局变量
typedef int KeyType;
typedef int info;
typedef struct
{
KeyType key;
//info otherinfo;
}ElemType;

typedef struct
{
ElemType *elem;
int count;
int sizeindex;
}HashTable;

int InitHashTable(HashTable &H)
{ // 操作结果: 构造一个空的哈希表
int i;
H.count=0; // 当前元素个数为0
H.sizeindex=0; // 初始存储容量为hashsize[H.sizeindex]
m=hashsize[0];
H.elem=(ElemType*)malloc(m*sizeof(ElemType));
if(!H.elem)
exit(0); // 存储分配失败
for(i=0;i<m;i++)
H.elem[i].key=NULLKEY; // 未填记录的标志
return OK;
}

void DestroyHashTable(HashTable &H)
{ // 初始条件: 哈希表H存在。操作结果: 销毁哈希表H
free(H.elem);
H.elem=NULL;
H.count=0;
H.sizeindex=0;
}//DestroyHashTable

int Hash(KeyType K)
{ // 一个简单的哈希函数(m为表长，全局变量)
//除留余数法
return K%m;
}//Hash

void collision(int &p,int d) // 线性探测再散列
{ // 开放定址法处理冲突
p=(p+d)%m;
}//collision

int SearchHash(HashTable H,KeyType K,int &p,int &c)
{
p=Hash(K); //求得哈希地址
while(H.elem[p].key!=NULLKEY && !EQ(K,H.elem[p].key))    //如果该位置填有记录，并且关键字不相等
{
collision(p,++c); //探测下一个位置p
if(c>=m)
break;
}
if(EQ(K,H.elem[p].key))        //查找成功，p返回待查数据元素位置
return SUCCESS;
else                        //查找不成功(H.elem[p].key==NULLKEY)
return UNSUCCESS;        //p返回的是插入位置
}//SearchHash

int InsertHash(HashTable &H,ElemType e);

void RecreateHashTable(HashTable &H) // 重建哈希表
{
int i,count=H.count;
ElemType *p,*elem=(ElemType*)malloc(count*sizeof(ElemType));
p=elem;
printf("重建哈希表\n");
for(i=0;i<m;i++)            // 先保存原有的数据到elem中
if((H.elem+i)->key!=NULLKEY) // 该单元有数据
*p++=*(H.elem+i);
H.count=0;      // H.coun重置为0
H.sizeindex++; // 增大存储容量
m=hashsize[H.sizeindex];
p=(ElemType*)realloc(H.elem,m*sizeof(ElemType));
if(!p)
exit(-1); // 存储分配失败
H.elem=p;
for(i=0;i<m;i++)
H.elem[i].key=NULLKEY; // 未填记录的标志(初始化)
for(p=elem;p<elem+count;p++) // 将原有的已经保存的数据按照新的表长插入到重建的哈希表中
InsertHash(H,*p);
}//RecreateHashTable

int InsertHash(HashTable &H,ElemType e)
{ // 查找不成功时插入数据元素e到开放定址哈希表H中，并返回OK；
// 若冲突次数过大，则重建哈希表
int c,p;
c=0;
if(SearchHash(H,e.key,p,c)) // 表中已有与e相同的元素
return DUPLICATE;    //SUCCESS=1
else if(c<hashsize[H.sizeindex]/2) // 冲突次数c未达到上限,(c的阀值可调)
{ // 插入e
H.elem[p]=e;
++H.count;
return OK;
}
else
RecreateHashTable(H); // 冲突次数c达到上限，将原来的哈希表重建，不包括现在正要插入的数据e
return ERROR;
}

int InsertHashD(HashTable &H)
{
ElemType e;
printf("input the data until -1\n");
scanf("%d",&e.key);
while(e.key!=-1)
{
InsertHash(H,e);
scanf("%d",&e.key);
}//while
return 1;
}//InsertHashD

int SearchHashD(HashTable &H)
{
KeyType key;
int p=0,c=0;
printf("input the data you want to search:\n");
scanf("%d",&key);
if(SearchHash(H,key,p,c))
printf("the location is %d,%d\n",p,H.elem[p].key);
else printf("Search Failed!\n");
return 1;
}//SearchHashD

void print(int p,ElemType r)
{
printf("address=%d (%d)\n",p,r.key);
}//print

void TraverseHash(HashTable H,void(*Vi)(int,ElemType))
{ // 按哈希地址的顺序遍历哈希表
printf("哈希地址0～%d\n",m-1);
for(int i=0;i<m;i++)
if(H.elem[i].key!=NULLKEY) // 有数据
Vi(i,H.elem[i]);
}//TraverseHash

void TraverseHashD(HashTable &H)
{
TraverseHash(H,print);
}//TraverseHashD

int main()
{
HashTable H;
InitHashTable(H);        //初始化
InsertHashD(H);            //构造哈希表
//SearchHashD(H);            //查找
TraverseHashD(H);        //遍历
DestroyHashTable(H);    //销毁
return 1;
}