/*
goal, 数据结构C语言版P259，哈希表。需要选择好哈希函数，冲突处理函数。
env, gcc
date, 2013-2-20
blog, http://blog.csdn.net/shunqiziranhao007/article/details/7816788
*/
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define SUCCESS 1
#define UNSUCCESS 0
#define NULLKEY 0 // 0为无记录标志
#define N 10 // 数据元素个数
typedef int KeyType;
typedef struct
{
KeyType key;
int ord;
} ElemType;
// 开放定址哈希表的存储结构
// 哈希表容量递增表，一个合适的素数序列
int hashsize[] = { 11, 19, 29, 37};
// 哈希表表长，全局变量
int m = 0;
typedef struct
{
// 数据元素存储基址，动态分配数组
ElemType *elem;
// 当前数据元素个数
int count;
// hashsize[sizeindex]为当前容量
int sizeindex;
} HashTable;
// 构造一个空的哈希表
void InitHashTable(HashTable *H)
{
int i;
(*H).count = 0;
// 初始存储容量为hashsize[0]
(*H).sizeindex = 0;
// 记录表长
m = hashsize[0];
(*H).elem = (ElemType*)malloc(m*sizeof(ElemType));
if( (*H).elem == NULL )
exit(0); // 存储分配失败
for(i = 0; i < m; i++)
(*H).elem[i].key = NULLKEY;
}
// 销毁哈希表
void DestroyHashTable(HashTable *H)
{
free((*H).elem);
(*H).elem = NULL;
(*H).count = 0;
(*H).sizeindex = 0;
}
// 一个简单的哈希函数(m为表长，全局变量)
unsigned Hash(KeyType K)
{
return K % m;
}
// 开放定址法处理冲突, 线性探测再散列
void collision(int *p, int d)
{
*p = (*p+d) % m;
}
// 算法9.17
// 在开放定址哈希表H中查找关键码为K的元素,若查找成功,以p指示待查数据
// 元素在表中位置,并返回SUCCESS;否则,以p指示插入位置,并返回UNSUCCESS
// c用以计冲突次数，其初值置零，供建表插入时参考。
int SearchHash(HashTable H, KeyType K, int *p, int *c)
{
// 求得哈希地址
*p = Hash(K);
while(H.elem[*p].key != NULLKEY && !(K == H.elem[*p].key))
{
// 该位置中填有记录．并且关键字不相等，冲突加1
(*c)++;
if(*c < m)
// 求得下一探查地址p
collision(p, *c);
else
break;
}
if (K == H.elem[*p].key)
return SUCCESS; // 查找成功，p返回待查数据元素位置
else
return UNSUCCESS; // 查找不成功
}
int InsertHash(HashTable *,ElemType);
// 重建哈希表
void RecreateHashTable(HashTable *H)
{
int i, count = (*H).count;
ElemType *p, *elem;
p = elem = (ElemType*)malloc(count * sizeof(ElemType));
printf("重建哈希表\n");
// 保存原有的数据到elem中
for(i = 0; i < m; i++)
{
// 该单元有数据
if(((*H).elem+i)->key != NULLKEY)
*p++ = *((*H).elem+i);
}
(*H).count = 0;
// 增大存储容量
(*H).sizeindex++;
m = hashsize[(*H).sizeindex];
p = (ElemType*)realloc((*H).elem, m * sizeof(ElemType));
if(!p)
exit(0);
(*H).elem = p;
for(i = 0; i < m; i++)
(*H).elem[i].key = NULLKEY;
// 将原有的数据按照新的表长插入到重建的哈希表中
for(p = elem; p < elem+count; p++)
InsertHash(H, *p);
}
// 算法9.18
// 查找不成功时插入数据元素e到开放定址哈希表H中，并返回1；
// 若冲突次数过大，则重建哈希表。
int InsertHash(HashTable *H, ElemType e)
{
int p, c = 0;
// 表中是否已有与e有相同关键字的元素
if(SearchHash(*H, e.key, &p, &c))
{
return -1;
}
else if(c < hashsize[(*H).sizeindex]/2)
{
// 冲突次数c未达到上限,(c的阀值可调)
(*H).elem[p] = e;
++(*H).count;
return 1;
}
else
{
// 重建哈希表
RecreateHashTable(H);
}
return 0;
}
// 在开放定址哈希表H中查找关键码为K的元素,若查找成功,以p指示待查数据
// 元素在表中位置,并返回SUCCESS;否则,返回UNSUCCESS
int Find(HashTable H, KeyType K, int *p)
{
int c = 0;
// 求得哈希地址
*p = Hash(K);
while(H.elem[*p].key != NULLKEY && !(K == H.elem[*p].key))
{
// 该位置中填有记录．并且关键字不相等
c++;
if(c < m)
// 求得下一探查地址p
collision(p, c);
else
// 查找不成功
return UNSUCCESS;
}
if (K == H.elem[*p].key)
// 查找成功，p返回待查数据元素位置
return SUCCESS;
else
// 查找不成功(H.elem[p].key==NULLKEY)
return UNSUCCESS;
}
// 按哈希地址的顺序遍历哈希表
void TraverseHash(HashTable H, void(*vi)(int, ElemType))
{
int i;
printf("哈希地址0～%d\n", m-1);
for(i = 0; i < m; i++)
{
// 有数据
if(H.elem[i].key != NULLKEY)
vi(i, H.elem[i]);
}
printf("\n");
}
void print(int p, ElemType r)
{
printf("address=%d\t (%2d, %2d)\n", p, r.key, r.ord);
}
int main()
{
ElemType r[N] = {
{17,1}, {60,2}, {29,3}, {38,4}, {1,5},
{2,6}, {3,7}, {4,8}, {60,9}, {13,10},
};
HashTable h;
int i, j, p;
KeyType k;
InitHashTable(&h);
for(i = 0; i < N-1; i++)
{
j = InsertHash(&h, r[i]);
if(j == -1)
printf("表中已有关键字为%d的记录，无法再插入记录(%d,%d)\n",
r[i].key, r[i].key, r[i].ord);
}
printf("\n按哈希地址的顺序遍历哈希表:\n");
TraverseHash(h, print);
printf("请输入待查找记录的关键字: ");
scanf("%d", &k);
j = Find(h, k, &p);
if(j == SUCCESS)
print(p, h.elem[p]);
else
printf("没找到\n");
// 插入第N个记录
j = InsertHash(&h, r[i]);
if(j == 0)
// 重建哈希表后重新插入第N个记录
j = InsertHash(&h, r[i]);
printf("按哈希地址的顺序遍历重建后的哈希表:\n");
TraverseHash(h,print);
printf("请输入待查找记录的关键字: ");
scanf("%d", &k);
j = Find(h, k, &p);
if(j == SUCCESS)
print(p, h.elem[p]);
else
printf("没找到\n");
DestroyHashTable(&h);
return 0;
}
/*
输出效果：
表中已有关键字为60的记录，无法再插入记录(60,9)
按哈希地址的顺序遍历哈希表:
哈希地址0～10
address=1 ( 1, 5)
address=2 ( 2, 6)
address=3 ( 3, 7)
address=4 ( 4, 8)
address=5 (60, 2)
address=6 (17, 1)
address=7 (29, 3)
address=8 (38, 4)
请输入待查找记录的关键字: 4
address=4 ( 4, 8)
重建哈希表
按哈希地址的顺序遍历重建后的哈希表:
哈希地址0～18
address=0 (38, 4)
address=1 ( 1, 5)
address=2 ( 2, 6)
address=3 ( 3, 7)
address=4 ( 4, 8)
address=6 (60, 2)
address=10 (29, 3)
address=13 (13, 10)
address=17 (17, 1)
请输入待查找记录的关键字: 5
没找到
*/