哈希表--开散列（哈希桶，拉链法）

##functions.h

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

typedef int KeyType;//关键字类型
typedef int ValueType;//个数类型

typedef struct HashNode //哈希链式节点
{
	KeyType _key;//关键字值
	ValueType _value;//个数
	struct HashNode* _next;//指向下个节点的指针
}HashNode;

typedef struct HashTable//哈希表
{

	HashNode** _tables;   // hashnode *表示数组内每个元素类型 ，*table表示数组
	size_t _size;//数组内已用个数
	size_t _capacity;//数组最大容量
}HashTable;

HashNode* BuyHashNode(KeyType key, ValueType value)
{
	HashNode *newnode = (HashNode*)malloc(sizeof(HashNode));
	assert(newnode);
	newnode->_key = key;
	newnode->_next = NULL;
	newnode->_value = value;
	return newnode;
}
void HashPrint(HashTable *ht)
{
	assert(ht);
	for (size_t i = 0;i < ht->_capacity;i++)
	{

		HashNode *cur = ht->_tables[i];
		printf("%d:", i);
		while (cur)
		{
			printf("[%d %d]->", cur->_key, cur->_value);
			cur = cur->_next;
		}
		printf("NULL\n");

	}
}
size_t HashFunc(KeyType key, size_t capacity)
{
	return key % capacity;
}
size_t GetNextPrimeNum(size_t cur)
{
	int i = 0;
	const int _PrimeSize = 28;
	static const unsigned long _PrimeList[28] =
	{
		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
	};
	for (int i = 0;i < 28;i++)
	{
		if (_PrimeList[i] >(unsigned long)cur)
		{
			return _PrimeList[i];
		}
	}
	return _PrimeList[i];

}
void HashTableInit(HashTable* ht, size_t capacity)
{
	assert(ht);
	ht->_tables = (HashNode**)malloc(sizeof(HashNode*)*capacity);
	assert(ht->_tables);
	ht->_size = 0;
	ht->_capacity = capacity;
	//注意每个数组元素要设置为NULL
	for (size_t i = 0;i < ht->_capacity;i++)
	{
		ht->_tables[i] = NULL;
	}
}
void HashTableDestory(HashTable* ht)
{
	assert(ht);
	for (size_t i = 0;i < ht->_capacity;i++)
	{
		HashNode *cur = ht->_tables[i];
		while (cur)
		{
			HashNode *next = cur->_next;
			free(cur);
			cur = next;
		}
	}
	free(ht->_tables);
	ht->_size = ht->_capacity = 0;

}
void check_capacity(HashTable *ht)
{
	assert(ht);
	if (ht->_size == ht->_capacity)//扩容条件
	{
		HashTable newtable;
		HashTableInit(&newtable, GetNextPrimeNum(ht->_capacity));
		for (size_t i = 0;i < ht->_capacity;i++)//依次将旧表的数据指向新表的映射点
		{
			HashNode *cur = ht->_tables[i];
			while (cur)
			{
				HashNode *next = cur->_next;
				size_t index = HashFunc(cur->_key, newtable._capacity);
				cur->_next = newtable._tables[index];
				newtable._tables[index] = cur;
				cur = next;
			}
		}
		//完成扩容+转移后，仍然使用旧表ht;
		HashTableDestory(ht);
		ht->_tables = newtable._tables;
		ht->_size = newtable._size;
		ht->_capacity = newtable._capacity;

	}
}
void HashTableInsert(HashTable* ht, KeyType key, ValueType value)
{
	assert(ht);
	//检查是否需要扩容
	check_capacity(ht);
	//求映射点
	size_t index = HashFunc(key, ht->_capacity);
	//判断该key值已经在哈希表中
	HashNode *cur = ht->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			cur->_value++;
			return;

		}
		cur = cur->_next;
	}
	HashNode *newnode = BuyHashNode(key, value);
	newnode->_next = ht->_tables[index];
	ht->_tables[index] = newnode;
	ht->_size++;
}
HashNode* HashTableFind(HashTable* ht, KeyType key)
{
	assert(ht);
	size_t index = HashFunc(key, ht->_capacity);
	HashNode *cur = ht->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			return cur;
		}
		cur = cur->_next;
	}
	printf("can not find the key!\n");
	return NULL;

}
//成功删除返回1 ，删除失败返回0；
int HashTableRemove(HashTable* ht, KeyType key)
{
	//找映射点，变成从单链表中删除一个节点,删除时检查该key值得
	//value值，如果>1的话减1，如果等于1直接删除。
	assert(ht);
	size_t index = HashFunc(key, ht->_capacity);
	HashNode *cur = ht->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			if (cur->_value > 1)
			{
				cur->_value--;
				return 1;
			}
			if (cur->_next)
			{
				//要删除的节点value值为1且不是尾节点，可以使用替换法
				HashNode *next = cur->_next;
				cur->_key = next->_key;
				cur->_value = next->_value;
				cur->_next = next->_next;
				free(next);
				next = NULL;
				return 1;
			}
			else
			{
				//说明要删除的节点是尾节点且value值为1
				HashNode *pcur = ht->_tables[index];

				if (pcur = cur)
				{
					//说明该哈希地址出只有1个节点且是要删除的那个
					free(pcur);
					ht->_tables[index] = NULL;
					return 1;
				}
				while (pcur->_next != cur)
				{
					pcur = pcur->_next;
				}
				pcur->_next = NULL;
				free(cur);
				cur = NULL;
				return 1;

			}
		}
		cur = cur->_next;

	}
	return 0;//没有找到
}

##test.c

#include"functions.h"

void test()
{
	HashTable ht;
	HashTableInit(&ht, 13);

	HashTableInsert(&ht, 14, 2);
	HashTableInsert(&ht, 27, 1);
	HashTableInsert(&ht, 1, 1);
	HashTableInsert(&ht, 3, 1);

	HashPrint(&ht);
	printf("\n\n");
	HashTableRemove(&ht,14);
	


	HashPrint(&ht);



}

int main()
{
	test();
	system("pause");
	return 0;
}