搜索结构之哈希

最新推荐文章于 2025-04-14 10:32:08 发布

原创最新推荐文章于 2025-04-14 10:32:08 发布

· 340 阅读

0 ·

版权

数据结构专栏收录该内容

12 篇文章

订阅专栏

哈希表是一种在O(1)时间内查找元素的数据结构，通过哈希函数实现关键码与存储位置的对应。文章介绍了哈希冲突及其解决方法，包括优化哈希函数、闭散列（开放地址法，如线性探测和二次探测）和开散列（链地址法）。文章讨论了负载因子在决定哈希表性能中的作用，并提供了相关代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

哈希表：哈希表是一种可以在O(1)时间内查找到某个元素的数据结构，它是用数组实现的，这依赖于内存的随机访问特性。那哈希表到底是什么样呢？哈希表是通过哈希函数（hashfunc）使元素的存储位置与关键码一一对应的关系，所以在进行元素查找的时候可以通过该函数快速的找到该元素。若结构中存在关键字和key相等的元素，则必然存储在f(k)的位置上。由此，不需要进行比较便可以直接取得所查记录。这个对应函数就被称为散列函数（哈希函数），依照这个思想所建立出来的表就被称为散列表（哈希表）。

常见的哈希函数有很多种，在这里我先用除留余数法简单的画一下哈希表是怎样存储元素的。

但是有没有发现一个问题，如果我们想再存入一个值为16的元素，应该把它存在哪里，这就是哈希冲突问题；所谓哈希冲突就是对于两个不同的数据元素m和n，存在HashFunc(m)==HashFunc(n);即不同的关键字计算出相同的哈希地址，这种现象称为哈希冲突或者哈希碰撞，把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

那我们应该怎样去很好的解决掉哈希冲突问题呢？

一般来说有三种解决方式:

第一种：引起哈希冲突的一个很可能的因素就是哈希函数设计的不够合理，哈希函数设计时应遵从下面几条原则：

1.哈希函数的定义域必须包含需要存储的所有关键码，即如果哈希表中有m个地址时，其值域必须在0~m-1之间。

2.哈希函数计算出来的哈希地址应该均匀的分布在整个哈希表中。

3.哈希函数的设计应该进可能的简单一点。

常见的哈希函数可自行百度。

第二种：闭散列

闭散列也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明哈希表中还有位置，可以把key放在下一个空位中去，那么如何去寻找下一个空余位置呢？

线性探测：举个例子：

根据闭散列线性的处理哈希冲突的方法，我们不难发现，不能随便删除哈希表中的元素，如果直接删除会影响其他元素的搜索。假设我们在上面例子中的哈希表中删除了元素32，当我们再想去查找元素12的时候，我们会首先去位置2的地方去找，此时我们发现位置2是空着的，我们就会认为12不存在于哈希表中，我们肯定就不再去向后进行查找了。（只有当位置2的不为空的时候，我们才会认为有可能发生了哈希冲突，才会去向后继续查找）。

采用线性探测的方法非常简单，但是当大量的哈希冲突聚集在一起，容易产生“数据堆积”，不同的关键码占据了可利用的空位置，使得寻找某一个关键字可能需要进行多次的比较，降低了搜索效率。那么如何缓解这种问题呢？我们引入了散列表的负载因子a=插入表中的元素个数/散列表的长度；a是散列表装满程度的标志因子，a越大，表明表中的元素越多，产生冲突的可能性就越大；反之，a越小，表明插入表中的元素就越少，产生哈希冲突的可能性就越小，实际上，散列表的平均查找长度是负载因子a的函数，只是不同处理冲突的方法有不同的函数。对于开放定址法，a非常重要，一般控制在0.7-0.8以下，当插入表中的元素个数=a*散列表长度时，我们就认为该哈希表已经满了，不可以再进行插入元素了。a超过0.8，查表时的cpu缓存命不中的概率呈指数上升趋势。

二次探测：发生哈希冲突时，二次探测法在表中查找下一个空位置的计算公式为： Hi=(H0+i^2)%m;Hi=(H0-i^2)%m;i=1,2,3...

m为哈希表的大小。

在上面的例子中，哈希冲突有三个元素：25，35和55，当插入5的时候直接存在了位置5处，插入35的时候发现位置5被占用了，所以就不能根据公式Hi=(H0+i^2)%m=(5+1)%10=6;尝试去往位置6出插入，发现位置6也被占用了，于是根据公式Hi=(H0-i^2）%m=(5-1)%10=4;尝试往位置4进行插入，位置4为空，所以将35插在了位置4处。接下来插入最后一个元素55时发现4和6的位置都被占用了，于是根据公式Hi=(H0+i^2)%m=(5+2^2)%10=9(此时i=2);尝试向位置9进行插入，并插入成功。

研究表明：当表的程度为质数且表的负载因子不超过0.5时，新的元素一定能够插入，而且任意一个位置都不会被探查两次，因此表中只要有一半的空位置，就不存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入元素的时候必须保证负载因子a不超过0.5，如果超出必须对哈希表进行增容。

用闭散列实现哈希结构的代码如下：

//hash_table.h
#pragma once 
#include<stddef.h>
#include<Windows.h>
#include<stdio.h>
#define Header printf("=============%s===============\n",__FUNCTION__);
#define HashMaxSize 1000 

typedef enum Stat { 
 Empty, 
 Valid, 
 Invalid // 当前元素被删除了 
} Stat; 

typedef int KeyType; 
typedef int ValType; 

typedef size_t (*Hashfunc)(KeyType); 

typedef struct HashElem { 
 KeyType key; 
 ValType value; 
 Stat stat; // 引入一个 stat 标记来作为是否有效的标记 
} HashElem; 

typedef struct HashTable { 
 HashElem data[HashMaxSize]; 
 size_t size; 
 Hashfunc hash_func; 
} HashTable; 

void HashInit(HashTable* ht, Hashfunc hash_func); 
size_t HashfuncDefault(KeyType key);
void HashPrint(HashTable* ht,const char* msg);
int HashInsert(HashTable* ht, KeyType key, ValType value); 
// 输入key, 查找对应key的value. 
int HashFind(HashTable* ht, KeyType key, ValType* value); 
void HashRemove(HashTable* ht, KeyType key); 
int HashEmpty(HashTable* ht); 
size_t HashSize(HashTable* ht); 
void HashDestroy(HashTable* ht); 
void CountNum(HashTable* ht);//统计每个元素出现了几次

//hash_table.c
#include "hash_table.h"
size_t HashfuncDefault(KeyType key)
{
	return key%HashMaxSize;
}
void HashInit(HashTable* ht, Hashfunc hash_func)
{
	size_t i=0;
	if(ht==NULL)//非法输入
	{
		return;
	}
	ht->hash_func=hash_func;
	ht->size=0;
	for(; i<HashMaxSize; ++i)
	{
		ht->data[i].stat=Empty;
	}
	return;
}
int HashInsert(HashTable* ht, KeyType key, ValType value)
{
	size_t offset;
	if(ht==NULL)
	{
		return 0;
	}
	if(ht->size>HashMaxSize*0.8)//负载因子设为0.8
	{
		return 0;
	}
	offset=ht->hash_func(key);
	while(1)
	{
		if(ht->data[offset].stat==Valid)
		{
			if(ht->data[offset].key==key)
			{
				return 0;
			}
			++offset;
		   if(offset>=HashMaxSize)
		   {
			offset-=HashMaxSize;
		   }
		}
		else
		{
			ht->data[offset].key=key;
			ht->data[offset].value=value;
			ht->data[offset].stat=Valid;
			++ht->size;
			break;
		}
	}
	return 1;
}
void HashPrint(HashTable* ht,const char* msg)
{
	size_t i=0;
	printf("%s>\n",msg);
	for(; i<HashMaxSize; ++i)
	{
		if(ht->data[i].stat!=Empty)
		{
		printf("[%lu] key:[%d]       value[%d]   stat[%d]",i,ht->data[i].key,
			ht->data[i].value,ht->data[i].stat);
		printf("\n");
		}
		
	}
}
int HashFind(HashTable* ht, KeyType key, ValType* value)
{
	size_t offset;
	if(ht==NULL)
	{
		return 0;
	}
	offset=ht->hash_func(key);
	while(1)
	{
	if(key==ht->data[offset].key&&ht->data[offset].stat==Valid)//找到了
	{
		*value=ht->data[offset].value;
		return 1;
	}
	else if(ht->data[offset].stat==Empty)
	{
		return 0;
	}
	else
	{
		++offset;
		if(offset>=HashMaxSize)
		{
			offset-=HashMaxSize;
		}
	}
	}
	return 0;
}
void HashRemove(HashTable* ht, KeyType key)
{
	size_t offset;
	if(ht==NULL)
	{
		return;
	}
	offset=ht->hash_func(key);
	while(1)
	{
		if(key==ht->data[offset].key&&ht->data[offset].stat==Valid)//找到了
		{
			ht->data[offset].stat=Invalid;
			--ht->size;
			return;
		}
		else if(ht->data[offset].stat==Empty)
		{
			break;
		}
		else
		{
			++offset;
			if(offset>=HashMaxSize)
			{
				offset-=HashMaxSize;
			}
		}
	}
}
void HashDestroy(HashTable* ht)
{
	size_t i=0;
	if(ht==NULL)
	{
		return;
	}
	for(; i<HashMaxSize; ++i)
	{
		ht->data[i].stat=Empty;
	}
	ht->size=0;
	ht->hash_func=NULL;
	return;
}
int HashEmpty(HashTable* ht)
{
	if(ht==NULL)
	{
		return 1;
	}
	return ht->size==0?1:0;
}
size_t HashSize(HashTable* ht)
{
	if(ht==NULL)
	{
		return 0;
	}
	return ht->size;
}

void CountNum(HashTable* ht)
{
	int arr[]={1,2,4,2,1,4,1};
	int i=0;
	int ret=0;
	int value=0;
	int sz=sizeof(arr)/sizeof(arr[0]);
	Header;
	HashInit(ht,HashfuncDefault);
	for(; i<sz; ++i)
	{
		ret=HashFind(ht,arr[i],&value);
		if(ret==0)
		{
			HashInsert(ht,arr[i],1);
		}
		else
		{
			HashRemove(ht,arr[i]);
			HashInsert(ht,arr[i],value+1);
		}
	}
	for(i=0; i<sz; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
	HashPrint(ht,"统计之后的结果为");
}

//测试用例test.c
#include "hash_table.h"
void TestInit()
{
	HashTable ht;
	size_t i=0;
	Header;
	HashInit(&ht,HashfuncDefault);
	printf("size expect 0,actual %d\n",ht.size);
	printf("ht->hash_func expect %p,actual %p\n",HashfuncDefault,ht.hash_func);
	for(i=0;i<HashMaxSize; ++i)
	{
		if(ht.data[i].stat!=Empty)
		{
			printf("pos [%lu] elem error!\n",i);
		}
	}
}
void TestInsert()
{
	HashTable ht;
	Header;
	HashInit(&ht,HashfuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,1003,400);
	HashInsert(&ht,2,500);
	HashInsert(&ht,5,600);
	HashPrint(&ht,"向哈希表插入六个元素");

}
void TestFind()
{
	HashTable ht;
	int ret;
	int value=0;
	Header;
	HashInit(&ht,HashfuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,1003,400);
	HashInsert(&ht,2,500);
	HashInsert(&ht,5,600);
	ret=HashFind(&ht,1002,&value);
	printf(" ret expect 1,actual %d\n value expect 300,actual %d\n",ret,value);
	ret=HashFind(&ht,3,&value);
    printf(" ret expect 0,actual %d\n",ret);

}
void TestRemove()
{
	HashTable ht;
	Header;
	HashInit(&ht,HashfuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,1003,400);
	HashInsert(&ht,2,500);
	HashInsert(&ht,5,600);
	HashRemove(&ht,1002);
	HashPrint(&ht,"删除1002之后的结果为");
}
void TestDestroy()
{
	HashTable ht;
	Header;
	HashInit(&ht,HashfuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,1003,400);
	HashInsert(&ht,2,500);
	HashInsert(&ht,5,600);
	HashDestroy(&ht);
	HashPrint(&ht,"销毁后的结果为");
}
void TestEmpty()
{
	HashTable ht;
	int ret;
	Header;
	HashInit(&ht,HashfuncDefault);
	ret=HashEmpty(&ht);
	printf("ret expect 1,actual %d\n",ret);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	ret=HashEmpty(&ht);
	printf("ret expect 0,actual %d\n",ret);

}
void TestSize()
{
	HashTable ht;
	size_t size;
	Header;
	HashInit(&ht,HashfuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,1001,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,1003,400);
	size=HashSize(&ht);
	printf("size expect 4,actual %lu\n",size);
}
void TestCountNum()
{
	HashTable ht;
	Header;
	HashInit(&ht,HashfuncDefault);
	CountNum(&ht);
}
int main()
{
	
	TestInit();
	TestInsert();
	TestFind();
	TestRemove();
	TestDestroy();
	TestEmpty();
	TestSize();
	TestCountNum();
	system("pause");
	return 0;
}

第三种：开散列

开散列法又叫做链地址法（开链法）；首先对每个关键码使用哈希函数求哈希地址，具有相同地址的关键码归于同一个集合，每一个集合称为一个桶，各个桶中的元素通过一个单链表连接起来，各链表的节点存储在一个哈希表中。

那么开散列哈希桶是怎样存储的呢？

通常情况下，每个桶对应的节点很少，将n个关键码通过某一哈希函数，存放到哈希表中的m个桶中，那么每一个链表的平均长度为：n/m;以搜索平均长度为：n/m的链表代替搜索长度为n的顺序表，效率高了很多。

应用链地址法需要增加链接指针，这看似增加了存储开销，实际上，由于开地址法必须保证大量的空闲空间以确保搜索效率，如二次探测法要求负载因子a<0.5;而表项所占空间又比指针大的多，所以从本质上来说使用链地址法反而比开地址法更加节省空间。

下面是开散列的代码实现：

//hash_table.h
#pragma once 

#include <stddef.h>
#include<Windows.h>
#include<stdio.h>

#define HashMaxSize 1000 

typedef int KeyType; 
typedef int ValType; 

typedef size_t (*HashFunc)(KeyType key); 

typedef struct HashElem { 
 KeyType key; 
 ValType value; 
 struct HashElem* next; 
} HashElem; 

// 数组的每一个元素是一个不带头结点的链表 
// 对于空链表, 我们使用 NULL 来表示 
typedef struct HashTable { 
 HashElem* data[HashMaxSize]; 
 size_t size; 
 HashFunc hash_func; 
} HashTable; 

void HashInit(HashTable* ht, HashFunc hash_func); 

// 约定哈希表中不能包含 key 相同的值. 
int HashInsert(HashTable* ht, KeyType key, ValType value); 

int HashFind(HashTable* ht, KeyType key, ValType* value); 

void HashRemove(HashTable* ht, KeyType key); 

size_t HashSize(HashTable* ht); 

int HashEmpty(HashTable* ht); 

void HashDestroy(HashTable* ht);

//hash_table.c
#include "hash_table2.h"
void HashInit(HashTable* ht, HashFunc hash_func)
{
	size_t i=0;
	if(ht==NULL)
	{
		return;
	}
	ht->size=0;
	ht->hash_func=hash_func;
	for(; i<HashMaxSize; ++i)
	{
		ht->data[i]=NULL;
	}
	return;
}

HashElem* HashBucketFind(HashElem* head,KeyType key)
{
	HashElem* cur;
	if(head==NULL)
	{
		return NULL;
	}
	cur=head;
	for(; cur!=NULL; cur=cur->next)
	{
		if(cur->key!=key)
		{
			continue;
		}
		else
		{
			return cur;
		}
	}
	return NULL;
}
HashElem* CreateHashNode(KeyType key,KeyType value)
{
	HashElem* new_node=(HashElem*)malloc(sizeof(HashElem));
	new_node->key=key;
	new_node->value=value;
	new_node->next=NULL;
	return new_node;
}
int HashInsert(HashTable* ht, KeyType key, ValType value)
{
	size_t offset;
	HashElem* res;
	HashElem* new_node;
	if(ht==NULL)
	{
		return 0;
	}
	offset=ht->hash_func(key);
	res=HashBucketFind(ht->data[offset],key);
	if(res!=NULL)
	{
		return 0;
	}
	else
	{
		new_node=CreateHashNode(key,value);
		new_node->next=ht->data[offset];
		ht->data[offset]=new_node;
		++ht->size;
		return 1;
	}
	return 0;
}

int HashFind(HashTable* ht, KeyType key, ValType* value)
{
	size_t offset;
	HashElem* res;
	if(ht==NULL||value==NULL)
	{
		return 0;
	}
	offset=ht->hash_func(key);
	res=HashBucketFind(ht->data[offset],*value);
	if(res==NULL)
	{
		return 0;
	}
	else
	{
		*value=ht->data[offset]->value;
		return 1;
	}
	return 0;
}
int HashBucketFindPrevandcur(HashElem* head,KeyType key,HashElem** cur_output,HashElem** prev_output)
{
	HashElem* pre=NULL;
	HashElem* cur=head;
	if(head==NULL||cur_output==NULL||prev_output==NULL)
	{
		return 0;
	}
	for(; cur!=NULL; pre=cur, cur=cur->next)
	{
		if(cur->key==key)
		{
			*cur_output=cur;
			*prev_output=pre;
			return 1;
		}
	}
	return 0;
}
void DestroyHashNode(HashElem* ptr)
{
	free(ptr);
}
void HashRemove(HashTable* ht, KeyType key)
{
	size_t offset;
    int res;
	HashElem* cur;
	HashElem* pre;
	if(ht==NULL)
	{
		return;
	}
	offset=ht->hash_func(key);
	pre=NULL;
	cur=ht->data[offset];
	res=HashBucketFindPrevandcur(ht->data[offset],key,&cur,&pre);
	if(res==0)
	{
		return;
	}
	if(cur==ht->data[offset])
	{
		ht->data[offset]=cur->next;
	}
	else
	{
		pre->next=cur->next;
	}
	DestroyHashNode(cur);
	--ht->size;
	return;
}
size_t HashSize(HashTable* ht)
{
	if(ht==NULL)
	{
		return 0;
	}
	return ht->size;
}
int HashEmpty(HashTable* ht)
{
	if(ht==NULL)
	{
		return 0;
	}
	return ht->size==0?1:0;
}

void HashDestroy(HashTable* ht)
{
	size_t i=0;
	HashElem* cur;
	HashElem* to_delete;
	if(ht==NULL)
	{
		return;
	}
	ht->hash_func=NULL;
	ht->size=0;
	
	for(i=0;i<HashMaxSize; ++i)
	{
		cur=ht->data[i];
		while(cur!=NULL)
		{
			to_delete=cur;
			cur=cur->next;
			DestroyHashNode(to_delete);
		}
	}
}

//测试用例test.c
#include "hash_table2.h"
#define HEADER printf("================%s=================\n",__FUNCTION__);
size_t HashFuncDefault(KeyType key)
{
	return key%HashMaxSize;
}
void HashPrint(HashTable* ht,const char* msg)
{
	size_t i=0;
	HashElem* cur;
	if(ht==NULL)
	{
		return;
	}
	printf("[%s]\n",msg);
	
	for(i=0; i<HashMaxSize; ++i)
	{
		if(ht->data[i]!=NULL)
		{
		cur=ht->data[i];
		for(; cur!=NULL; cur=cur->next)
		 {
			printf("[%d]  ",i);
			printf("%d:%d;",ht->data[i]->key,ht->data[i]->value);
		 }
		printf("\n");
		}
	}
}
void TestInit()
{
	HashTable ht;
	size_t i=0;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	printf("size expect 0,actual %d\n",ht.size);
	printf("HashFunc expect %p,actual %p\n",HashFuncDefault,ht.hash_func);
	for(i=0; i<HashMaxSize; ++i)
	{
		if(ht.data[i]!=NULL)
		{
			printf("pos[%lu] error!\n",i);
		}
	}

}
void TestInsert()
{
	HashTable ht;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1001,300);
	HashInsert(&ht,3,400);
	HashPrint(&ht,"插入四个元素");
	printf("size %d\n",ht.size);
	

}
void TestFind()
{
	HashTable ht;
	ValType value=0;
	int ret;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1001,300);
	HashInsert(&ht,3,400);
	ret=HashFind(&ht,3,&value);
	printf("ret expect 1,ectual %d\n",ret);
	printf("value expect 400,actual %d\n",value);

}
void TestRemove()
{
	HashTable ht;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1001,300);
	HashInsert(&ht,3,400);
	HashRemove(&ht,1);
	HashPrint(&ht,"删除1之后的结果为");
}
void	TestSize()
{
	HashTable ht;
	int ret;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1001,300);
	HashInsert(&ht,3,400);
	ret=HashSize(&ht);
	printf("ret expect 4,actual %d\n",ret);
}
void TestEmpty()
{
	HashTable ht;
	int ret;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	ret=HashEmpty(&ht);
	printf("ret expect 1,actual %d\n",ret);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1001,300);
	HashInsert(&ht,3,400);
	ret=HashEmpty(&ht);
	printf("ret expect 0,actual %d\n",ret);
}
void TestDestroy()
{
	HashTable ht;
	HEADER;
	HashInit(&ht,HashFuncDefault);
	HashInsert(&ht,1,100);
	HashInsert(&ht,2,200);
	HashInsert(&ht,1002,300);
	HashInsert(&ht,3,400);
	HashDestroy(&ht);
	printf("size expect 0,actual %d\n",ht.size);
}

int main()
{
	TestInit();
	TestInsert();
	TestFind();
	TestRemove();
	TestSize();
	TestEmpty();
	TestDestroy();
	system("pause");
	return 0;
}