链式哈希表

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/AlbertoNo1/article/details/51156279

链式哈希表介绍

        待补充

链式哈希表实现

// Chtbl.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>


/*链表元素结构体定义*/
typedef struct ListElmt_
{
	void *pdata;
	struct ListElmt_ *pNext;
}ListElmt;

/*链表结构体定义*/
typedef struct List_
{
	int iSize;
	void (*destory)(void *data);
	ListElmt *ListElmtHead;
	ListElmt *ListElmtTail;
}List;

/*链表操作宏定义*/
#define LIST_SIZE(list) ((list)->iSize)
#define LIST_HEAD(list) ((list)->ListElmtHead)
#define LIST_TAIL(list) ((list)->ListElmtTail)
#define LIST_IS_HEAD(list, element) ((element == (list)->ListElmtHead) ? 1:0)
#define LIST_IS_TAIL(list, element) ((element == (list)->ListElmtTail) ? 1:0)
#define LIST_DATA(element) ((element)->pdata)
#define LIST_NEXT(element) ((element)->pNext)

/*
*函数名：List_Init
*参数：list  链表
*      destory  释放链表节点内存的函数
*功能：单链表初始化
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void List_Init(List *list, void (*destory)(void *data))
{
	/*入参合法性由调用者保证*/

	list->iSize = 0;
	list->destory = destory;
	list->ListElmtHead = NULL;
	list->ListElmtTail = NULL;

	return ;
}

/*
*函数名：List_Ins_Next
*参数：list  链表
*      Element  待插入元素的前一个节点元素
*      data     待插入元素数据
*功能：单链表添加节点函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int List_Ins_Next(List *list, ListElmt *Element, void *data)
{
	ListElmt *Lelmt = NULL;

	if ((NULL == list) || (NULL == data))
	{
		return -1;
	}

	/*申请链表节点内存*/
	Lelmt = (ListElmt*)malloc(sizeof(ListElmt));
	if (NULL == Lelmt)
	{
		return -1;
	}

	Lelmt->pdata = data;

	if (NULL == Element)
	{
		/*在链表头插入元素*/
		Lelmt->pNext = list->ListElmtHead;
		list->ListElmtHead = Lelmt;

		if (0 == LIST_SIZE(list))
		{
			list->ListElmtTail = Lelmt;
		}
	}
	else
	{
		/*在非链表头插入元素*/
		Lelmt->pNext = Element->pNext;
		Element->pNext = Lelmt;

		if (NULL == Lelmt->pNext)
		{
			list->ListElmtTail = Lelmt;
		}
	}

	/*链表大小加1*/
	list->iSize++;

	return 0;
}

/*
*函数名：List_Rem_Next
*参数：list  链表
*      Element  待删除元素的前一个节点元素
*      data     返回删除元素的数据域
*功能：单链表删除节点函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int List_Rem_Next(List *list, ListElmt *Element, void **data)
{
	ListElmt *Old_Lelmt = NULL;

	if ((NULL == list) || (NULL == data))
	{
		return -1;
	}

	if (0 == LIST_SIZE(list))
	{
		return -1;
	}

	if (NULL == Element)
	{
		/*删除链表头元素*/
		*data = list->ListElmtHead->pdata;
		Old_Lelmt = list->ListElmtHead;
		list->ListElmtHead = list->ListElmtHead->pNext;

		if (1 == LIST_SIZE(list))
		{
			list->ListElmtTail = NULL;
		}

	}
	else
	{
		/*删除非链表头元素*/
		if (1 == LIST_SIZE(list))
		{
			return -1;
		}
		else
		{
			*data = Element->pNext->pdata;
			Old_Lelmt = Element->pNext;
			Element->pNext = Element->pNext->pNext;

			if (NULL == Element->pNext)
			{
				list->ListElmtTail = Element;
			}
		}
	}

	/*释放删除节点的内存*/
	free(Old_Lelmt);

	/*链表大小减一*/
	list->iSize--;

	return 0;
}

/*
*函数名：List_Destory
*参数：list  链表
*功能：单链表销毁
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void List_Destory(List *list)
{
	void *data = NULL;

	/*入参合法性由调用者保证*/

	while (LIST_SIZE(list) > 0)
	{
		if ((0 == List_Rem_Next(list, NULL, &data))&&(NULL != list->destory))
		{
			list->destory(data);
		}
	}

	memset(list, 0, sizeof(List));

	return ;
}

/*
*函数名：destory
*参数：data  动态申请内存的地址
*功能：释放动态申请内存函数
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void destory(void *data)
{
	free(data);
}

/*链式哈希表数据结构*/
typedef struct CHTbl_
{
	int buckets;  /*桶的个数*/

	int (*hash_func)(const void *key);
	int (*match)(const void *key1, const void *key2);
	void (*destroy)(void *data);

	int size;
	List *table;

}CHTbl;

/*链式哈希表操作宏定义*/
#define chtbl_size(htbl) ((htbl)->size)
#define CHTBL_BUCKETS   (100)

/*
*函数名：chtbl_hash
*参数：key  哈希键值
*功能：哈希函数
*返回值：哈希值
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_hash(const void *key)
{
	int value = *((int*)key);

	return value%CHTBL_BUCKETS;
}

/*
*函数名：chtbl_match
*参数：pKey1  指向第一个比较元素的地址
*      pKey2  指向第二个比较元素的地址
*功能：比较两个元素的大小
*返回值：1 表示Key1 大于 Key2
*        -1 表示Key1 小于 Key2
*        0 表示Key1 等于 Key2
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_match(const void *pKey1, const void *pKey2)
{
	/*对两个整型数进行比较*/
	if (*((int*)pKey1) > *((int*)pKey2))
	{
		return 1;
	}
	else if (*((int*)pKey1) < *((int*)pKey2))
	{
		return -1;
	}
	else
	{
		return 0;
	}
}

/*
*函数名：chtbl_init
*参数：htbl  链式哈希表
*      buckets  哈希表桶个数
*      h_func   哈希函数
*      m_func   元素比较函数
*      d_func   元素动态申请内存释放函数
*功能：链式哈希表初始化函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_init(CHTbl *htbl, int buckets, int (*h_func)(const void *key),int (*m_func)(const void *key1, const void *key2),
	            void (*d_func)(void *data))
{
	int i = 0;

	/*为哈希表申请内存空间*/
	htbl->table = (List*)malloc(buckets*sizeof(List));
	if (NULL == htbl->table)
	{
		return -1;
	}

	/*初始化（链表）桶*/
	htbl->buckets = buckets;
	for (i = 0; i < buckets; i++)
	{
		List_Init(&(htbl->table[i]), destory);
	}

	htbl->hash_func = h_func;
	htbl->match = m_func;
	htbl->destroy = d_func;

	htbl->size = 0;

	return 0;
}

/*
*函数名：chtbl_destory
*参数：htbl  链式哈希表
*功能：链式哈希表销毁函数
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-14
*/
void chtbl_destory(CHTbl *htbl)
{
	int i = 0;

	/*销毁（链表）桶*/
	for (i = 0; i < htbl->buckets; i++)
	{
		List_Destory(&(htbl->table[i]));
	}

	/*释放哈希表内存*/
	free(htbl->table);

	memset(htbl, 0, sizeof(CHTbl));

	return ;
}

/*
*函数名：chtbl_lookup
*参数：htbl  链式哈希表
*      data  待查找元素数据
*功能：链式哈希表元素查找函数
*返回值：0 哈希表中存在此元素  -1 哈希表中不存在此元素
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_lookup(const CHTbl *htbl, void **data)
{
	ListElmt  *element = NULL;
	int   bucket = 0;

	/*获得哈希值*/
	bucket = htbl->hash_func(*data)%(htbl->buckets);


	/*在（链表）桶中查找元素*/
	for (element = LIST_HEAD(&(htbl->table[bucket])); element != NULL; element = LIST_NEXT(element))
	{
		if (htbl->match(*data, LIST_DATA(element)) == 0)
		{/*找到该元素*/
			*data = LIST_DATA(element);
			return 0;
		}
	}

	/*该元素未找到*/
	return -1;
}

/*
*函数名：chtbl_insert
*参数：htbl  链式哈希表
*      data  待插入桶中的元素
*功能：链式哈希表添加元素函数
*返回值：0 成功  1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_insert(CHTbl *htbl, const void *data)
{
	void *temp = NULL;

	int bucket = 0;
	int retval = 0;

	/*如果哈希表中已经存在该元素，直接返回*/
	temp = (void*)data;
	if (chtbl_lookup(htbl, &temp) == 0)
	{
		return 1;
	}

	/*获得哈希值*/
	bucket = htbl->hash_func(data)%(htbl->buckets);

	/*把元素插到对应的桶中*/
	retval = List_Ins_Next(&(htbl->table[bucket]), NULL, (void*)data);
	if (0 == retval)
	{/*插入成功*/
		htbl->size++;
	}

	return retval;
}

/*
*函数名：chtbl_remove
*参数：htbl  链式哈希表
*      data  待从桶中删除的元素
*功能：链式哈希表删除元素函数
*返回值：0 成功  -1 失败
*作者：AlbertoNo1
*日期：2016-04-14
*/
int chtbl_remove(CHTbl *htbl, const void **data)
{
	ListElmt  *element = NULL;
    ListElmt  *prev = NULL;
	int   bucket = 0;  

	/*获得哈希值*/
	bucket = htbl->hash_func(*data)%(htbl->buckets);

	/*在对应的链表桶中查找该元素*/
	for (element = LIST_HEAD(&(htbl->table[bucket])); element != NULL; element = LIST_NEXT(element))
	{
		if (htbl->match(*data, LIST_DATA(element)) == 0)
		{/*找到该元素*/
			/*从（链表）桶中移除该元素*/
			if (List_Rem_Next(&(htbl->table[bucket]), prev, (void**)data) == 0)
			{
				htbl->size--;
				return 0;
			}
			else
			{
				return -1;
			}
		}

		prev = element;
	}

	/*哈希表中不存在想要删除的元素*/
	return -1;
}


int _tmain(int argc, _TCHAR* argv[])
{
	int iRet = 0;
	int iLoop = 0;
	int *piData = NULL;

	CHTbl stCHtbl = {0};

	chtbl_init(&stCHtbl, CHTBL_BUCKETS, chtbl_hash, chtbl_match, destory);

	for (iLoop = 0; iLoop < 10; iLoop++)
	{
		piData = (int*)malloc(sizeof(int));
		*piData = iLoop;
		iRet |= chtbl_insert(&stCHtbl,(void*)piData);
	}

	if (0 != iRet)
	{
		return -1;
	}

	piData = (int*)malloc(sizeof(int));
	*piData = 9;

	iRet = chtbl_lookup(&stCHtbl, (void**)&piData);

	printf("%d \r\n", iRet);

	free(piData);

	piData = (int*)malloc(sizeof(int));
	*piData = 10;

	iRet = chtbl_lookup(&stCHtbl, (void**)&piData);

	printf("%d \r\n", iRet);

	free(piData);

	piData = (int*)malloc(sizeof(int));
	*piData = 9;

	iRet = chtbl_remove(&stCHtbl, (const void**)&piData);

	printf("%d \r\n", iRet);

	free(piData);

	piData = (int*)malloc(sizeof(int));
	*piData = 9;

	iRet = chtbl_lookup(&stCHtbl, (void**)&piData);

	printf("%d \r\n", iRet);

	free(piData);

	chtbl_destory(&stCHtbl);

	getchar();
	return 0;
}