ADT - Hash Table(散列表)

/**
 *     ADT - Hash table(散列表)
 *
 *		链接法(chaining)
 */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

#define bool int
#define true  1
#define false 0

#define ListSize 10

typedef struct LinkedList {
	struct LinkedList* next;		//当发生冲突时申请额外节点来存放冲突值
	int key;		//key-value
	int count;		//list个数
}HashChain;			//链接法

struct HashList {
	HashChain* Node;
}hashlist[ListSize];	//建立hashlist-LiseSize

/* 定义全部函数 */
HashChain* initHashtable();
bool ListEmpty();
bool ListFull();
int GetListCount();
static int Hashmap();
static bool HashCollision();
bool InsertList();
int FindListKey();
bool DeleteList();

/**
 *	初始化hashlist的每一个位置的节点与个数
 */
HashChain* initHashtable(void)
{
	HashChain* table;
	int i;

	for(i = 0; i < ListSize; i++)
	{
		hashlist[i].Node = NULL;
	}

	table = (HashChain*)malloc(sizeof(HashChain));
	table->count = 0;
	table->next = NULL;

	return table;
}

/**
 *	判断hash表是否为空
 */
bool ListEmpty(HashChain* table)
{
	return table->count == 0;
}

/**
 *	判断hash表是否满
 */
bool ListFull(HashChain* table)
{
	return table->count == ListSize;
}
/**
 *　　　当前散列表中存在的数据个数
 */
int GetListCount(HashChain* table)
{
	return table->count;
}

/**
 *	哈希函数-映射，将value映射为hash table中的一个地址
 */
static int Hashmap(int val)
{
	return val % ListSize;
}

/**
 *	判断映射地址是否发生了冲突
 */
static bool HashCollision(int val)
{
	if(hashlist[Hashmap(val)].Node != NULL )	//检查val的映射地址的第一个节点是否存在，存在则说明冲突。时间复杂度O(1)
		return false;

	return true;
}

/**
 *		插入数据
 */
bool InsertList(HashChain* table, int X)
{
	HashChain* list, * temp;

	if(ListFull(table))		//如果list满了
	{
		fprintf(stderr, "HashList is full!\n");
		return false;		//提前退出
	}
	else if(HashCollision(X))		//如果没冲突
	{
		hashlist[Hashmap(X)].Node = (HashChain*)malloc(sizeof(HashChain));		//对该地址申请一个节点，把节点保存到list中
		temp = (HashChain*)malloc(sizeof(HashChain));
		temp->key = X;
		temp->next = NULL;
		hashlist[Hashmap(X)].Node->next = temp;
	}
	else if(!HashCollision(X))		//如果冲突
	{
		list = hashlist[Hashmap(X)].Node;	//为了防止改变冲突的原地址的节点，把地址赋给一个hash结构变量，让它来完成查找插入的位置的任务
		while(list->next != NULL)	//链表的线性查找，使得新插入的值插入到该地址中的链表的尾部
		{
			list = list->next;
		}
		temp = (HashChain*)malloc(sizeof(HashChain));
		temp->key = X;
		list -> next = temp;
		temp -> next = NULL;
	}
	++table->count;	//计数

	return true;
}

/**
 *		查找数据
 */
int FindListKey(HashChain* table, int X)
{
	HashChain* list;

	if(ListEmpty(table))		//如果表为空，节省一点查找的时间
	{
		fprintf(stderr, "HashList is empty!\n");
		return false;
	}
	else if(HashCollision(X))		//如果没有冲突，说明表中不存在该数据
	{
		fprintf(stderr, "Not the data exist!\n");
		return false;
	}
	else		//如果冲突，则从该地址中的链表的第一个节点开始比较查找，查找的时间复杂度为O(n)，n为链表的节点个数，最坏情况为O(ListSize)，最好情况为O(1)
	{
		list = hashlist[Hashmap(X)].Node;
		while(list->next->key != X)
		{
			list = list->next;
		}
		return list->next->key;
	}
}

/**
 *		删除数据
 */
bool DeleteList(HashChain* table, int X)
{
	HashChain* list, * temp;

	if(ListEmpty(table))		//如果表为空，节省一点查找的时间
	{
		fprintf(stderr, "HashList is empty!\n");
		return false;
	}
	else if(HashCollision(X))		//如果没有冲突，说明表中不存在该数据
	{
		fprintf(stderr, "Not the data exist!\n");
		return false;
	}
	else if(!HashCollision(X))
	{
		list = hashlist[Hashmap(X)].Node;
		if(list->next == NULL)
		{
			temp = list;
			free(temp);
		}
		else
		{
			while(list->next != NULL && list->next->key != X)
			{
				temp = list;
				list = list->next;
			}
			temp = list->next;
			list->next = list->next->next;
			free(temp);
		}
		temp = NULL;    //防止野指针
	}
	--table->count;

	return true;
}

int main(void)
{
	HashChain* table, * PrintKey;
	int val;
	char c;

	table = initHashtable();
	puts("1) 添加		2) 删除");
	puts("3) 查找		4) 关键值个数");
	puts("5) 显示指定地址中的所有关键值");
	puts("6) 退出");

	while((c = getch()) != ‘6‘)
	{
		switch(c)
		{
		case ‘1‘ :	printf("\n添加数据:");
					scanf("%d", &val);
					InsertList(table, val);
				break;
		case ‘2‘ :	printf("\n删除数据:");
					scanf("%d", &val);
					DeleteList(table, val);
				break;
		case ‘3‘ :	printf("\n查找数据:");
					scanf("%d", &val);
					if(FindListKey(table, val))
						printf("您查找的数据为:%d\n", FindListKey(table, val));
				break;
		case ‘4‘ :	printf("\n当前关键值个数为: %d\n", GetListCount(table));
				break;
		case ‘5‘ :	printf("输入关键值:");
					scanf("%d", &val);

					printf("显示数据:");
					PrintKey = hashlist[Hashmap(val)].Node;
					while(PrintKey->next != NULL)
					{
						PrintKey = PrintKey->next;
						printf("%d ", PrintKey->key);
					}
					printf("\n");
				break;
		}
	}
	free(table);
	table = NULL;    //防止野指针

	return 0;
}