HashTable设计

构造方法：

1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b，其中a和b为常数（这种散列函数叫做自身函数）。若其中H(key）中已经有值了，就往下一个找，直到H(key）中没有值了，就放进去。 

2. 数字分析法：分析一组数据，比如一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体相同，这样的话，出现冲突的几率就会很大，但是我们发现年月日的后几位表示月份和具体日期的数字差别很大，如果用后面的数字来构成散列地址，则冲突的几率会明显降低。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。 　　

3. 平方取中法：取关键字平方后的中间几位作为散列地址。 　　

4. 折叠法：将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。 　　

5. 随机数法：选择一随机函数，取关键字的随机值作为散列地址，通常用于关键字长度不同的场合。

6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。

处理冲突的方法：

1. 开放寻址法：Hi=(H(key) + di) MOD m,i=1,2，…，k(k<=m-1），其中H(key）为散列函数，m为散列表长，di为增量序列，可有下列三种取法： 　

1.1. di=1,2,3，…，m-1，称线性探测再散列； 　

1.2. di=1^2,-1^2,2^2,-2^2，⑶^2，…，±（k)^2,(k<=m/2）称二次探测再散列； 　　

1.3. di=伪随机数序列，称伪随机探测再散列。 　　

2. 再散列法：Hi=RHi(key),i=1,2，…，k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。 　　

3. 链地址法（拉链法） 　　

4. 建立一个公共溢出区

一个HashTable的例子：

#include <stdio.h>
#include <malloc.h>

#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; // 当前数据元素个数
	int sizeindex; // hashsize[sizeindex]为当前容量
} HashTable;

#define SUCCESS 1
#define UNSUCCESS 0
#define DUPLICATE -1

// 构造一个空的哈希表
int InitHashTable(HashTable *H) {
	int i;
	(*H).count = 0; // 当前元素个数为0
	(*H).sizeindex = 0; // 初始存储容量为hashsize[0]
	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 1;
}

//  销毁哈希表H
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)) {
		// 该位置中填有记录．并且关键字不相等
		(*c)++;
		if (*c < m)
			collision(p, *c); // 求得下一探查地址p
		else
			break;
	}
	if (K == H.elem[*p].key)
		return SUCCESS; // 查找成功，p返回待查数据元素位置
	else
		return UNSUCCESS; // 查找不成功(H.elem[p].key==NULLKEY)，p返回的是插入位置
}

int InsertHash(HashTable *, ElemType); // 对函数的声明

// 重建哈希表
void RecreateHashTable(HashTable *H) {
	int i, count = (*H).count;
	ElemType *a, *elem = (ElemType*) malloc(count * sizeof(ElemType));
	a = elem;
	printf("重建哈希表\n");
	for (i = 0; i < m; i++) // 保存原有的数据到elem中
		if (((*H).elem + i)->key != NULLKEY) // 该单元有数据
			*elem++ = *((*H).elem + i);
	elem = a;
	(*H).count = 0;
	(*H).sizeindex++; // 增大存储容量
	m = hashsize[(*H).sizeindex];
	ElemType *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 (i = 0; i < count; i++) // 将原有的数据按照新的表长插入到重建的哈希表中
		InsertHash(H, *(elem + i));
}
//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).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 c, p;
	c = 0;
	if (SearchHash(*H, e.key, &p, &c)) // 表中已有与e有相同关键字的元素
		return DUPLICATE;
	else if (c < hashsize[(*H).sizeindex] / 2) // 冲突次数c未达到上限,(c的阀值可调)
	{
		// 插入e
		(*H).elem[p] = e;
		++(*H).count;
		return 1;
	} else {
		RecreateHashTable(H); // 重建哈希表
		InsertHash(H, e);
	}
	return 0;
}

// 按哈希地址的顺序遍历哈希表
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]);
}

// 在开放定址哈希表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)
			collision(p, c); // 求得下一探查地址p
		else
			return UNSUCCESS; // 查找不成功(H.elem[p].key==NULLKEY)
	}
	if (K == H.elem[*p].key)
		return SUCCESS; // 查找成功，p返回待查数据元素位置
	else
		return UNSUCCESS; // 查找不成功(H.elem[p].key==NULLKEY)
}

void print(int p, ElemType r) {
	printf("address=%d (%d,%d)\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++) {
		// 插入前N-1个记录
		j = InsertHash(&h, r[i]);
		if (j == DUPLICATE)
			printf("表中已有关键字为%d的记录，无法再插入记录(%d,%d)\n", r[i].key, r[i].key,
					r[i].ord);
	}
	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");
	j = InsertHash(&h, r[i]); // 插入第N个记录
	if (j == 0) // 重建哈希表
		j = InsertHash(&h, r[i]); // 重建哈希表后重新插入第N个记录
	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);

	system("pause");
	return 0;
}