哈希表——拉链法

一、Hash.h

#ifndef __HASH_H__
#define __HASH_H__

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int KeyType;

typedef struct HashNode
{
	KeyType _key;
	struct HashNode* _next;
}HashNode;

typedef struct HashTable
{
	HashNode** _tables; //指针数组
	size_t _size;
	size_t _capacity;
}HashTable;

HashNode* BuyHashNode(KeyType key);
size_t HashFunc(HashTable* ht, KeyType key);
static size_t GetNextPrimeNum(HashTable* ht);

void HashTableInit(HashTable* ht, size_t Initsize);
int HashTableInsert(HashTable* ht, KeyType key);
HashNode* HashTableFind(HashTable* ht, KeyType key);
int HashTableRemove(HashTable* ht, KeyType key);
void HashTablePrint(HashTable* ht);
void HashTableDestory(HashTable* ht);

#endif __HASH_H__

二、Hash.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "Hash.h"

//初始化
void HashTableInit(HashTable* ht, size_t Initsize)
{
	assert(ht);
	ht->_tables = (HashNode**)malloc(Initsize*sizeof(HashNode*));
	assert(ht->_tables);
	ht->_size = 0;
	ht->_capacity = Initsize;
	for (size_t i = 0; i < ht->_capacity; i++)
	{
		ht->_tables[i] = NULL;
	}
}

//销毁
void HashTableDestory(HashTable* ht)
{
	assert(ht);
	for (size_t index = 0; index < ht->_capacity; index++) //先销毁每一个链表
	{
		HashNode* cur = ht->_tables[index];
		while (cur)
		{
			HashNode* next = cur->_next;
			free(cur);
			cur = NULL;
			cur = next;
		}
	}
	free(ht->_tables); //再销毁顺序表
	ht->_tables = NULL;
	ht->_size = ht->_capacity = 0;
}

//哈希函数-查找位置
size_t HashFunc(HashTable* ht, KeyType key)
{
	return key % ht->_capacity;
}

//素数表
static size_t GetNextPrimeNum(HashTable* ht)
{
	const int _PrimeSize = 28;
	static const unsigned long _PrimeList[_PrimeSize] =
	{
		53ul, 97ul, 193ul, 389ul, 769ul,
		1543ul, 3079ul, 6151ul, 12289ul,
		24593ul, 49157ul, 98317ul, 196613ul,
		393241ul, 786433ul, 1572869ul, 3145739ul,
		6291469ul, 12582917ul, 25165843ul, 50331653ul,
		100663319ul, 201326611ul, 402653189ul, 805306457ul,
		1610612741ul, 3221225473ul, 4294967291ul
	};
	int index = 0;
	while (index < _PrimeSize)
	{
		if (ht->_capacity < _PrimeList[index])
		{
			return _PrimeList[index];
		}
		index++;
	}
	return _PrimeList[_PrimeSize - 1];
}

//扩容
void Checkcapacity(HashTable* ht)
{
	assert(ht);
	if (ht->_size == ht->_capacity) //将载荷因子控制在1
	{
		HashTable newht; //新建一个哈希表
		HashTableInit(&newht, GetNextPrimeNum(ht));
		for (size_t i = 0; i < ht->_capacity; i++)
		{
			HashNode* cur = ht->_tables[i];
			while (cur)
			{
				HashNode* next = cur->_next; //保存下一个节点
				size_t index = HashFunc(&newht, cur->_key); //重新计算原哈希表中每一个key在新哈希表中的位置
				 //利用原来已开辟的空间来进行链接，不用再重新开辟空间
				cur->_next = newht._tables[index];		
				newht._tables[index] = cur;
				cur = next;
			}
			ht->_tables[i] = NULL;
		}
		free(ht->_tables); //销毁原哈希表
		ht->_tables = newht._tables; //更新哈希表
		ht->_capacity = newht._capacity;
	}
}

//创建结点
HashNode* BuyHashNode(KeyType key)
{
	HashNode* newnode = (HashNode*)malloc(sizeof(HashNode));
	assert(newnode);
	newnode->_key = key;
	newnode->_next = NULL;
	return newnode;
}

//插入
int HashTableInsert(HashTable* ht, KeyType key)
{
	assert(ht);
	Checkcapacity(ht);
	size_t index = HashFunc(ht, key);
	HashNode* cur = ht->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			return 0;
		}
		cur = cur->_next;
	}
	HashNode* newnode = BuyHashNode(key);
	newnode->_next = ht->_tables[index];
	ht->_tables[index] = newnode;
	ht->_size++;
	return 1;
}

//查找
HashNode* HashTableFind(HashTable* ht, KeyType key)
{
	assert(ht);
	size_t index = HashFunc(ht, key);
	HashNode* cur = ht->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

//删除
int HashTableRemove(HashTable* ht, KeyType key)
{
	assert(ht);
	size_t index = HashFunc(ht, key);
	HashNode* cur = ht->_tables[index];
	if (cur == NULL)
	{
		return 0;
	}
	else if (cur->_next == NULL)
	{
		if (cur->_key == key)
		{
			free(cur);
			ht->_tables[index] = NULL;
			ht->_size--;
			return 1;
		}
		return 0;
	}
	else
	{
		HashNode* prev = ht->_tables[index];
		while (cur)
		{
			if (cur->_key == key)
			{
				prev->_next = cur->_next;
				free(cur);
				cur = NULL;
				ht->_size--;
				return 1;
			}
			prev = cur;
			cur = cur->_next;
		}
		return 0;
	}	
}

//打印
void HashTablePrint(HashTable* ht)
{
	assert(ht);
	printf("\n");
	for (size_t index = 0; index < ht->_capacity; index++)
	{
		HashNode* cur = ht->_tables[index];
		while (cur)
		{
			printf("%d->", cur->_key);
			cur = cur->_next;
		}
		printf("NULL\n");
	}
	printf("\n");
}

三、Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "Hash.h"

int main()
{
	HashTable ht;
	HashTableInit(&ht, 5);
	int arr[] = { 10, 20, 30, 40, 50 };

	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		HashTableInsert(&ht, arr[i]);
	}
	HashTablePrint(&ht);

	HashNode* cur = HashTableFind(&ht, 1);
	if (cur)
	{
		printf("找到：%d\n", cur->_key);
	}
	else
	{
		printf("未找到\n");
	}

	HashTableInsert(&ht, 1);
	HashTableInsert(&ht, 2);
	HashTableInsert(&ht, 3);
	HashTableInsert(&ht, 4);
	HashTablePrint(&ht);

	cur = HashTableFind(&ht, 1);
	if (cur)
	{
		printf("找到：%d\n", cur->_key);
	}
	else
	{
		printf("未找到\n");
	}

	HashTableRemove(&ht, 1);
	HashTablePrint(&ht);

	cur = HashTableFind(&ht, 1);
	if (cur)
	{
		printf("找到：%d\n", cur->_key);
	}
	else
	{
		printf("未找到\n");
	}

	HashTableDestory(&ht);

	system("pause");
	return 0;
}