哈希表(HashTable)的开放定址法和链地址法的实现



散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。引用（百度）

算法时间复杂度分析：采用哈希表作为数据结构的存储系统中，根据关键字的值可快速定位到相应的地址上，在采用开放定址法时仅需O(1)复杂度就可找到，在采用链地址法时，需要O(N)复杂度，主要在链表中搜索，相对于搜索树的O(lg(N))的复杂度，开放定址法显然来得快，但是哈希表的长度会变得非常长，采用链地址法时快速定位到相应的头结点中，只需在链表中循环遍历即可，编程难度比树降低了不少，还可以将链地址法中哈希表数组中的指针指向一个树，这样在搜索时，快速定位到搜索树的根节点，根据树的对数搜索复杂度，更可快速的找到元素,比如说，红黑树，B树..

关于哈希表中的元素指针只想为树的结点时，相应的结构如下：

                                                   

下面采用开放定址法和链地址法实现哈希表:

1. 开放定址法：

include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)
typedef int KeyType;

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

struct ElemType{
	KeyType key;
	int order;
	struct ElemType*next;//方便在采用链地址法时用的
};
typedef struct HashTable1{
	ElemType *elem;//数据元素的基址
	int count;
	int hashindex;
}HashTable;

/*
	初始化哈希表
*/
void InitHashTable(HashTable&H){
	H.count = 0;
	H.hashindex = 0;
	m = hashsize[H.hashindex];//初始化哈希表表长为hashsize[H.hashindex]
	if ((H.elem = (ElemType*)malloc(sizeof(ElemType)*m)) == NULL){
		printf("初始化HashTable基址失败\n");
		exit(-1);
	}
	for (int i = 0; i < m; i++){
		H.elem[i].key = 0;//未填充的记录
	}
}

/*
Hash函数
采用取余法,用关键字的值余上表的长度,作为哈希存储的地址
*/
unsigned Hash(KeyType K){
	return K%m;
}
int d(int i){//增量序列是冲突次数i的函数
	return i;//线性探测再散列
	//return rand() 随机探测再散列，一班用线性探测再散列就够了
}


/*
开放定址法处理冲突
*/
void collision(KeyType K, int&p, int i){
	p = (Hash(K) + d(i)) % m;//最后得到的结果一定在0~m-1之间
}

/*
	在哈希表中查找关键字为K的记录，若找到了则返回success，p表示数据在表中的位置
	否则以p指示插入位置，并返回Unsuccess.i为冲突次数,传出参数
	*/
int SearchHash(HashTable&H, KeyType K, int &p, int &i){
	p = Hash(K);//根据关键字计算哈希地址
	while (H.elem[p].key != 0 && K != H.elem[p].key){//在所得的地址上关键字不为空，且不等于该位置上的关键字，则产生冲突
		++i;//冲突次数自增一次
		if (i < m){//还有可能找到位置
			collision(K, p, i);//计算下一个位置/根据开放定址法
		}
		else break;//否则找不到位置了s
	}
	if (K == H.elem[p].key){//找到了位置
		return 1;
	}
	else return 0;
}
int InsertHashTable(HashTable&H, ElemType e);
void RecreateHashTable(HashTable&H){
	int i, count = H.count;
	ElemType *p, *elem = (ElemType*)malloc(sizeof(ElemType)*count);
	p = elem;
	for (i = 0; i < m; i++){
		if (H.elem[i].key != 0){//H在该单元有数据
			*p++ = H.elem[i];
		}
	}//将H中的数据临时存放到elem中对应的位置上去
	H.count = 0;
	++H.hashindex;

	m = hashsize[H.hashindex];//新的存储容量
	H.elem = (ElemType*)realloc(H.elem, m*sizeof(ElemType));//利用H.elem重新分配表长大小为m哈希表长空间
	for (i = 0; i < m; i++){
		H.elem[i].key = 0;//赋初值
	}
	for (p = elem; p < elem + count; p++)
		InsertHashTable(H, *p);//将临时的数据再次插入到新构造的HashTable中
	free(elem);
}
/*
	在哈希表中插入数据项为e的元素
	*/
int InsertHashTable(HashTable&H, ElemType e){
	int p, c = 0;//c为冲突的次数
	if (SearchHash(H, e.key, p, c)){//如果找到了要插入的元素
		return -1;
	}
	else if (c < hashsize[H.hashindex] / 2){//未找到，冲突次数未达到上限
		H.elem[p] = e;
		H.count++;
		return 1;//插入成功
	}
	else {
		RecreateHashTable(H);//需重新建表
		return 0;
	}
}
/*
	遍历哈希
*/
void TraverseHashTable(HashTable H){
	for (int i = 0; i < m; i++){
		if (H.elem[i].key != 0)//第i个单元有数据
			printf("%d ,(%d,%d)\n", i, H.elem[i].key, H.elem[i].order);
	}
}

2. 接下来为链地址法处理冲突：

typedef int KeyType;

int hashsize[] = { 11, 19, 29, 37 };//哈希表容量递增表，一个合适的素数序列
int m;//哈希表的表长，全局变量
struct ElemType{
	KeyType key;
	int order;
	struct ElemType*next;
};
typedef struct HashTable2{
	ElemType **elem;//二级指针型向量，采用动态分配空间大小
	int count;//当前的头指针向量的元素
	int hashindex;//hashsize[H.hashindex]为当前容量
}HashTableLinkList;
//表的容量永远不会扩充，只是链地址的链表会很长,于是选择合适的表长变得 很重要了
/*
	在ELemTYpe形成的链表中查找关键字等于K的元素，L指向头结点
	动态查找的链表
	*/
int SearchHashTableElemType(ElemType *L, KeyType K, ElemType *&v){
	ElemType *s = NULL;
	s = (ElemType*)malloc(sizeof(ElemType));
	s->key = K;
	if (!L->next){//一开始为空，插入一个元素
		s->next = L->next;
		L->next = s;
		v = s;
		return 0;
	}
	else{
		//	printf("\n进入了尾插法\n");
		ElemType* p = L->next;
		ElemType *q = L;
		while (p&&p->key != K){
			q = p;
			p = p->next;
		}
		if (p&&p->key == K){
			v = p;
			return 1;//找到了数据元素
		}

		else{//插入一个数据,此时p为空,需要她的前驱指针q指向最后一个元素，采用尾插法插入元素
			s->next = q->next;
			q->next = s;
			v = s;
			return 0;
		}
	}

}
/*
	链地址法解决哈希冲突
	*/
void InitHashTableLinkListHash(HashTableLinkList &H){
	H.count = 0;
	m = hashsize[0];
	H.elem = (ElemType**)malloc(m*sizeof(ElemType*));
	for (int i = 0; i < m; i++){
		H.elem[i] = (ElemType*)malloc(sizeof(ElemType));
		H.elem[i]->next = NULL;
	}
}
/*
	计算哈希地址
	*/
int HashLinkList(KeyType K){
	return K%m;
}
/*
	在哈希表中查找元素,从哈希链地址中查找数据项值等于e的元素
	,不需要冲突次数
	*/
ElemType* SearchHashTableLinkList(HashTableLinkList H, KeyType K, int &p){
	//ElemType *v = NULL;
	p = Hash(K);//p为根据关键字计算的处的头结点所在的位置,关键
	//printf("%d\n",p);
	ElemType *head = H.elem[p];//记下头结点,关键字记录肯定在以head为头结点的单链表中
	return head;
	//SearchHashTableElemType(head, K, v);
	//return v;
}

/*
	遍历采用链地址法的哈希表
	*/
void TraverseHashTableLinkList(HashTableLinkList H){
	ElemType *p = NULL, *q = NULL;
	for (int i = 0; i < m; i++){
		if ((p = H.elem[i])->next){//头结点不空
			printf("\n进入了新的链表:\n");
			q = p->next;//指向首节点
			while (q){
				printf("%d ", q->key);
				q = q->next;
			}
		}
	}
	printf("\n");
}
/*
	在哈希表中插入一个元素
	*/
ElemType* InsertHashTableLinkList(HashTableLinkList&H, ElemType e){
	int p = 0;//为插入的位置
	ElemType*v = NULL;
	ElemType*head = SearchHashTableLinkList(H, e.key, p);//找到数据项e应该插入的头结点所在的链表
	//SearchHashTableLinkListElemType;
	SearchHashTableElemType(head, e.key, v);//动态查找链表
	return v;//返回这个结点,不管找没找到，找到了返回，没找到会自动插入这个元素也返回
	//在以head为头结点的链表中查找e.key关键字的元素
}