数据结构-哈希表（散列表）-查找方法-开放地址法

最新推荐文章于 2022-10-21 11:06:27 发布
最新推荐文章于 2022-10-21 11:06:27 发布
阅读量1.3k 收藏 7
点赞数 5
分类专栏： C/C++ 数据结构 文章标签： c++ 数据结构 哈希表 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44939707/article/details/116245981
版权

数据结构-哈希表（散列表）-查找-除留余数法-开放地址法
//代码附有详细注释
哈希表的动态生成和查找，
哈希函数为除留余数法，
处理冲突的方法为开放地址法。

常量，KC 关键码的个数

//常量
#define KC 14     //关键码的个数
#define SUCCESS 1
#define UNSUCCESS 0
#define DUPLICATE -1
#define NULLKEY 0
#define EQ(a, b) ((a)-(b))
#define LT(a, b) ((a)<(b))
#define LQ(a, b) ((a)<=(b))

哈希表容量递增表，一个合适的素数序列，m是哈希表表长，全局变量

//哈希表容量递增表，一个合适的素数序列，m是哈希表表长，全局变量
int hashsize[]={13,19,29,37};          
int m=0;

给元素和关键字起一个别名，如果需要更换元素和关键字类型只需要更改一处地方，并且写代码时ElemType比int更容易理解。

//元素类型，关键字类型            
typedef int ElemType;
typedef int KeyType;
typedef int Status;

开放定址哈希表的存储结构

//定义开放定址哈希表的存储结构
struct HashTable
{
	ElemType *elem;    //数据元素存储基址，动态分配数组
	int count;         //当前数据元素个数
	int sizeindex;     //hashsize[sizeindex]为当前容量
};

哈希表的初始化

//哈希表的初始化
Status lnitHashTable(HashTable *H)
{
	int i;
	m=hashsize[0];//hashsize[0]=13
	(*H).count=0; //当前元素个数为0	
	(*H).sizeindex=m; //初始存储容量
	(*H).elem=(ElemType*) malloc(m*sizeof(ElemType));//给哈希表申请空间地址
	if(!(*H).elem)//存储分配失败
	{
		printf("哈希表建立失败\n");
		exit(UNSUCCESS); 
	}
	for(i=0; i<m; i++)
	{
		(*H).elem[i]=NULLKEY; //未填记录的标志
	}
		return SUCCESS;
}

哈希表的销毁
申请动态空间后，注意在使用结束后释放动态空间。

//哈希表的销毁
void DestroyHashTable(HashTable *H)//初始条件：哈希表H存在
{	
	free((*H).elem);
	(*H).elem=NULL;
	(*H).count=0;
	(*H).sizeindex=0;
}

哈希函数：除留余数法
冲突解决办法：开放地址法

//哈希函数
unsigned int Hash(KeyType K)
{
	printf("\n关键码： %d  哈希函数 %d \n", K, K%m);
	return K%m;
}

//冲突解决方法(线性探测再散列)
void collision(int *p, int d)
{
	//开放定址法处理冲突
	*p=(*p+d)%m;
	printf("处理冲突后哈希地址 %d ",*p);
}

在开放定址哈希表H中查找关键码为K的元素

//查找(若该数据元素不在表中,则插入)
Status SearchHash(HashTable H, KeyType K, int *p, int *c)
{
	//在开放定址哈希表H中查找关键码为K的元素，若查找成功，以P指示待查数据元素在表中位置，并返回SUCCESS;
	//否则，以P指示插入位置，并返回 UNSUCCESS
	//c用以计冲突次数，其初值置零，供建表插入时参考。
	*p=Hash(K);//通过哈希函数求得哈希地址
	printf("哈希地址: %d ",*p);
	printf("此位置是否已有关键码: %d \n",H.elem[*p] != NULLKEY);
	while( H.elem[*p] != NULLKEY && EQ(K, H.elem[*p]) )    
		//位置中填有记录,并且关键字不相等
	{
			(*c)++;
			if(*c<m)
				collision(p,*c); //求得下一探查地址P
			else
				break;
			printf("处理冲突后的位置是否已有关键码: %d \n",H.elem[*p] != NULLKEY);
	}
	if (!EQ(K, H.elem[*p]))
	{
		return SUCCESS; //查找成功，P返回待查数据元素位置
	}
	else
		return UNSUCCESS; 
}

哈希表的重建
如果当前哈希表容量不够存储关键码（冲突次数过大），则需要重建哈希表

//哈希表的重建
Status lnsertHash(HashTable *H, ElemType);//lnsertHash函数的声明
void RecreateHashTable(HashTable *H, ElemType e)//重建哈希表
{
	int i;
	int count=(*H).count;
	ElemType *elem;
	ElemType *p=(ElemType*) malloc(count*sizeof(ElemType));
	printf("原先的的哈希表：\n");
	for(i=0; i<m; i++)//保存原有的数据到p中
	{
		if(((*H).elem[i]) != NULLKEY)   //该单元有数据
		{
			p[i]=(*H).elem[i];
			printf("(%d,%d) ",i,p[i]);
		}
		else 
		{
			p[i]=NULLKEY;
			printf("(%d,%d) ",i,p[i]);
		}
	}
	printf("\n");
	(*H).count=0;
	(*H).sizeindex++;//增大存储容量
	m=(*H).sizeindex;
	printf("增加哈希表的存储容量到%d \n新建哈希表:",m);
	elem=(ElemType*) realloc( (*H).elem, m*sizeof(ElemType));
	if(!elem) exit(0); //存储分配失败
	(*H).elem=elem;
	for(i=0; i<m; i++)	(*H).elem[i]=NULLKEY; //未填记录的标志(初始化)
	for(i=0; i<m-1; i++)	
	{
		lnsertHash(H,p[i]);//将原有的数据按照新的表长插入到重建的哈希表中		
	}
	lnsertHash(H,e);//最后一个数据
}

在哈希表中插入数据元素

//在哈希表中插入数据元素
Status lnsertHash(HashTable *H, ElemType e)
{
	//查找不成功时插入数据元素e到开放定址哈希表H中，并返回0K;
	//若冲突次数过大,则重建哈希表
	int c,p;
	c=0;
	if(SearchHash(*H,e,&p,&c))  //SearchHash函数返回1则说明表中已有与e有相同关键字的元素
	{
		printf("表中已有相同关键字的元素:%d\n", e);
		return DUPLICATE;
	}
	else 
		if( c < m)   //最大冲突次数		
		{	
			printf("冲突次数%d未达到上限\n", c );			
			(*H).elem[p]=e;//插入e
			(*H).count++;
			return SUCCESS;
		}
		else
		{
			printf("冲突次数达到上限时关键码为%d \n",e);
			RecreateHashTable(H,e); //重建哈希表
		}
		return UNSUCCESS;
}

哈希表的遍历

//哈希表的遍历
void TraverseHash(HashTable H)
{
	//按哈希地址的顺序遍历哈希表
	int i;
	printf("哈希地址0~%d\n", m-1);
	for(i=0; i<m; i++)
		if(H.elem[i]!=NULLKEY) //有数据
			printf("(%d, %d)  ",i,H.elem[i]);
		printf("\n");
		return;
}

主函数用于测试，数组数量在hashsize[0]之前无重建，hashsize[0]之后有重建。是否重建还与数组元素有关。

void main()
{
	KeyType key[]={19,01,23,14,55,20,84,27,68,11,10,77,63,45,24};//可自定义，但效果不一定很好。
	HashTable H;
	ElemType e;
	lnitHashTable(&H);    //构建了一个空的哈希表
	for(int i=0; i<KC; i++)
	{
		e=key[i];
		lnsertHash(&H, e);
	}
	TraverseHash(H);
    DestroyHashTable(&H);//哈希表的销毁
}

最后，如果觉得这篇博客能帮助到你，请点个小小的赞支持一下我（收藏也行呀，嘻嘻），这是我继续更新的动力呀，关注我可以得到第一时间的更新，更加快人一步哦。
如果有问题请在评论区留言，一起交流进步。
附完整代码：

#include "stdio.h"
#include "stdlib.h"
//常量
#define KC 14     //关键码的个数
#define SUCCESS 1
#define UNSUCCESS 0
#define DUPLICATE -1
#define NULLKEY 0
#define EQ(a, b) ((a)-(b))
#define LT(a, b) ((a)<(b))
#define LQ(a, b) ((a)<=(b))

//哈希表容量递增表，一个合适的素数序列，m是哈希表表长，全局变量
int hashsize[]={13,19,29,37};          
int m=0;

//元素类型，关键字类型            
typedef int ElemType;
typedef int KeyType;
typedef int Status;

//定义开放定址哈希表的存储结构
struct HashTable
{
	ElemType *elem;    //数据元素存储基址，动态分配数组
	int count;         //当前数据元素个数
	int sizeindex;     //hashsize[sizeindex]为当前容量
}; 

//哈希表的初始化
Status lnitHashTable(HashTable *H)
{
	int i;
	m=hashsize[0];//hashsize[0]=13
	(*H).count=0; //当前元素个数为0	
	(*H).sizeindex=m; //初始存储容量
	(*H).elem=(ElemType*) malloc(m*sizeof(ElemType));//给哈希表申请空间地址
	if(!(*H).elem)//存储分配失败
	{
		printf("哈希表建立失败\n");
		exit(UNSUCCESS); 
	}
	for(i=0; i<m; i++)
	{
		(*H).elem[i]=NULLKEY; //未填记录的标志
	}
	
		return SUCCESS;
}

//哈希表的销毁
void DestroyHashTable(HashTable *H)//初始条件：哈希表H存在
{	
	free((*H).elem);
	(*H).elem=NULL;
	(*H).count=0;
	(*H).sizeindex=0;
}

//哈希函数
unsigned int Hash(KeyType K)
{
	printf("\n关键码： %d  哈希函数 %d \n", K, K%m);
	return K%m;
}

//冲突解决方法(线性探测再散列)
void collision(int *p, int d)
{
	//开放定址法处理冲突
	*p=(*p+d)%m;
	printf("处理冲突后哈希地址 %d ",*p);
}

//查找(若该数据元素不在表中,则插入)
Status SearchHash(HashTable H, KeyType K, int *p, int *c)
{
	//在开放定址哈希表H中查找关键码为K的元素，若查找成功，以P指示待查数据元素在表中位置，并返回SUCCESS;
	//否则，以P指示插入位置，并返回 UNSUCCESS
	//c用以计冲突次数，其初值置零，供建表插入时参考。
	*p=Hash(K);//通过哈希函数求得哈希地址
	printf("哈希地址: %d ",*p);
	printf("此位置是否已有关键码: %d \n",H.elem[*p] != NULLKEY);
	while( H.elem[*p] != NULLKEY && EQ(K, H.elem[*p]) )    
		//位置中填有记录,并且关键字不相等
	{
			(*c)++;
			if(*c<m)
				collision(p,*c); //求得下一探查地址P
			else
				break;
			printf("处理冲突后的位置是否已有关键码: %d \n",H.elem[*p] != NULLKEY);
	}
	if (!EQ(K, H.elem[*p]))
	{
		return SUCCESS; //查找成功，P返回待查数据元素位置
	}
	else
		return UNSUCCESS; 
	//查找不成功Helem[*p]==NULLKEY,P返回的是插入位置
}

//哈希表的重建
Status lnsertHash(HashTable *H, ElemType);//lnsertHash函数的声明

void RecreateHashTable(HashTable *H, ElemType e)//重建哈希表
{
	int i;
	int count=(*H).count;
	ElemType *elem;
	ElemType *p=(ElemType*) malloc(count*sizeof(ElemType));
	printf("原先的的哈希表：\n");
	for(i=0; i<m; i++)//保存原有的数据到p中
	{
		if(((*H).elem[i]) != NULLKEY)   //该单元有数据
		{
			p[i]=(*H).elem[i];
			printf("(%d,%d) ",i,p[i]);
		}
		else 
		{
			p[i]=NULLKEY;
			printf("(%d,%d) ",i,p[i]);
		}
	}
	printf("\n");
	(*H).count=0;
	(*H).sizeindex++;//增大存储容量
	m=(*H).sizeindex;
	printf("增加哈希表的存储容量到%d \n新建哈希表:",m);
	elem=(ElemType*) realloc( (*H).elem, m*sizeof(ElemType));
	if(!elem) exit(0); //存储分配失败
	(*H).elem=elem;
	for(i=0; i<m; i++)	(*H).elem[i]=NULLKEY; //未填记录的标志(初始化)
	for(i=0; i<m-1; i++)	
	{
		lnsertHash(H,p[i]);//将原有的数据按照新的表长插入到重建的哈希表中		
	}
	lnsertHash(H,e);//最后一个数据
}

//在哈希表中插入数据元素
Status lnsertHash(HashTable *H, ElemType e)
{
	//查找不成功时插入数据元素e到开放定址哈希表H中，并返回0K;
	//若冲突次数过大,则重建哈希表
	int c,p;
	c=0;
	if(SearchHash(*H,e,&p,&c))     //表中已有与e有相同关键字的元素
	{
		printf("表中已有相同关键字的元素:%d\n", e);
		return DUPLICATE;
	}
	else 
		if( c < 12)		
		{	
			printf("冲突次数%d未达到上限\n", c );			
			(*H).elem[p]=e;//插入e
			(*H).count++;
			return SUCCESS;
		}
		else
		{
			printf("此时关键码为%d \n",e);
			RecreateHashTable(H,e); //重建哈希表
		}
		return UNSUCCESS;
}

//哈希表的遍历

void TraverseHash(HashTable H)
{
	//按哈希地址的顺序遍历哈希表
	int i;
	printf("哈希地址0~%d\n", m-1);
	for(i=0; i<m; i++)
		if(H.elem[i]!=NULLKEY) //有数据
		{
			printf("(%d, %d)  ",i,H.elem[i]);
			if(i%5==0) printf("\n");
		}
		printf("\n");
		return;
}
void main()
{
	KeyType key[]={19,01,23,14,55,20,84,27,68,11,10,77,63,45,24};
	HashTable H;
	ElemType e;
	lnitHashTable(&H);    //构建了一个空的哈希表
	for(int i=0; i<KC; i++)
	{
		e=key[i];
		lnsertHash(&H, e);
	}
	TraverseHash(H);
	DestroyHashTable(&H);//哈希表的销毁
	system("pause");
}
“翎羽”
关注
专栏目录
数据结构---散列表（哈希表）链地址法
化身强盗的博客
12-22 4912
散列表链地址法基本思想是将相同散列地址的元素放在同一个单链表中，即称同义词链表。例如此时我们设一个散列函数H(key)=key%n，则可以定义一个一维数组，大小为n，数组元素对应关键字模n所得的数字。 如下图：n为13，各关键字模13后插入对应值的表中。 代码部分 存储结构： typedef struct hashnode { int data; struct hashnode* next; }hashnode,*hashbit; data存元素值，next指向冲突元素地址。 相关函数：
[数据结构] --- 哈希表
最新发布
M2嵌入式
07-02 935
哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度（在此之前的我们都是采用遍历来查找指定元素，当数据量庞大时（亿万级别），挨个遍历就显得很慢，而哈希表可以通过某个函数直接访问到指定元素，这就是哈希表的NB之处）。。
C语言开放地址法哈希表构建
08-04
开放地址法哈希表构建，使用纯C语言实现，利用了泛型的思想进行编写。
详解哈希表的查找
数据与算法之美
02-28 1925
哈希表和哈希函数在记录的存储位置和它的关键字之间是建立一个确定的对应关系（映射函数），使每个关键字和一个存储位置能唯一对应。这个映射函数称为哈希函数，根据这个原则建立的表称为哈希表(Hash Table)，也叫散列表。以上描述，如果通过数学形式来描述就是：若查找关键字为 key，则其值存放在 f(key) 的存储位置上。由此，不需比较便可直接取得所查记录。注：哈希查找与线性表查找和树表查找最大的区
基于开发地址法的散列表的查找
weixin_44001521的博客
12-25 502
#include"pch.h" #include <iostream> using namespace std; //利用线性探测法 typedef int keyType; typedef struct { keyType key; }HashTable,*HashTree; class Hash { public: int curTable;//当前 //定义哈希函数 H...
基于开放地址法的哈希表（散列表）
hero_ache的博客
05-29 860
#include<iostream> #include<string> #include<cctype> #include<fstream> #include<algorithm> using namespace std; const int MaxSize = 97; typedef struct Element { int info;//info的用处是用来标记元素是否被删除过 int num; }Element; typedef stru
查找之散列表（开放定址法）
臻
11-11 183
在这里插入代码片#pragma once template<class T> class HashTable { class HashNode { public: T* elem; int count; ~HashNode() { if (elem)delete[] elem; } }H; public: HashTable(const int _count)...
基于C语言的数据结构-哈希表hashTable
06-25
哈希表，又称散列表，是一种非常重要的数据结构，它以高效的方式实现了数据的存储和检索。在C语言中，由于没有内置的哈希表实现，程序员需要自定义数据结构来构建哈希表。本教程将深入探讨如何利用C语言构建和操作...
Tabela-Hash:数据结构-哈希表
03-31
哈希表，也被称为散列表，是数据结构中一种高效的数据存储和检索工具。它通过将键（key）映射到一个确定的位置来实现快速访问，这个位置通常称为哈希码或哈希值。在C语言中实现哈希表，需要理解其基本原理和常见算法...
算法与数据结构 --- 查找 --- 散列表的查找
qq_51947882的博客
09-27 1397
1.开放地址法其实就是在出现冲突的时候，那么我们就在表中找一个新的存储位置来存储元素，如果这个存储位置对应的元素还不为空的话，那就继续存到新的存储位置，直到找到元素为空的存储位置为止（如果找编所有的存储位置都不行的话，那就返回表已满）查找的时候也同理，如果查找的值的关键字和计算出的存储位置的元素的关键字不同的话，我们就用整数取余法去看其它的存储位置元素，如果还是不相等的话那就继续获取新存储位置来查找，直到找到或者是存储位置超出散列表范围为止。
使用开放地址法的哈希表存储与查找
cnmdsbmdzz的博客
03-20 213
使用开放地址法的哈希表存储与查找   简单的给出两个初始的数组，然后定义两个函数insert（）和search（）实现插入和存储。 因为是简单实现，所以代码很简陋，看看就行。   如果不懂哈希表的原理可以参考一下文章，写的很好。 https://blog.csdn.net/u011080472/article/details/51177412 #include <iostream> using namespace std; #define N 5 #define NUM 7 #define ha
散列表-开放地址法
码农之道
08-12 1497
散列表的查找过程和建表过程相似。假设给定的值为K，根据建表时设定的散列函数h，计算出散列地址h(K)，若表中该地址单元为空，则查找失败；否则将该地址中的结点与给定值K比较。若相等则查找成功，否则按建表时设定的处理冲突的方法找下一个地址。如此反复下去，直到某个地址单元为空(查找失败)或者关键字比较相等(查找成功)为止。 （1）开放地址法一般形式的函数表示   int Hash(KeyType
利用开放定址法实现散列表的创建、插入、删除、查找操作_基于线性探索法的散列表...
weixin_39645308的博客
11-21 447
请先参阅深入理解散列表散列表的另一种实现用大小为M的数组保存N个键值对，其中M>N。我们需要依靠数组中的空位解决碰撞冲突。基于这种策略的所有方法被统称为开放地址散列表。开放地址散列表中最简单的方法叫做线性探测法：当碰撞发生时（当一个键的散列值已经被另一个不同的键占用），我们直接检测散列表的下一个位置（将索引加一）。这样的线性探测可能会产生三种情况：命中，该位置的键和被查找的键相同；未命中，键...
HashTable 基于开放地址法
......
04-13 193
该HashTable基于定常数组的开放地址法，搜索时采用线性探测发 由于删除时使用标志的做法，因此该HashTable常作删除会导致效率的下降。 为了保证此表的操作效率，数组的大小为所需要存储的数据的两倍。如果再细致一些，应该是大于其两倍的的第一个质数，这样可以减小Hash冲突的可能性，不过这里没有这样作，同样是为了代码清晰。 HashTable的遍历不占优势，此处没有实现。 API find：查...
散列表的查找和插入算法
热门推荐
单核CPU的小朋友的博客
10-09 5万+
散列表查找 散列表查找是一种特殊的查找方法，它能够通过对关键字的值快速定位待查找元素的位置。再查找方面，散列表有着极高的效率。但是一个散列表或多或少会存在冲突，为了解决冲突，我们设计了两个方法，一个是开放定址法，另一个就是拉链法。 开放定址法又分为线性探查法，二分探查法和双重散列法，就效率而言，双重散列法的效率是最优的，但是其中最为直观的方法还是线性探查法。 基本思想 使用某种方法在散列表中形成一...
58、【查找】哈希表——拉链法和开放地址寻址法（C/C++版）
STAR GAME
05-14 6838
一、算法介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。 哈希表实现将一个较大的集合映射到一个相对较小的集合内，在一个较大的值域里从中选
基于开放定址法的哈希造表和查找
libingbojava的博客
06-29 1487
为什么要用哈希查找 ?在之前学过的所有查找算法里 ,  不论是折半查找 , 亦或静态数表查找 , 还是索引顺序表查找 ,这些查找方式都是基于 "比较" 的查找方式.也就是说 , 想知道自己要查的元素在集合里有没有 , 把集合里的元素拿出来跟自己的元素一个一个比较 , 一样的话 , 就说明集合里有 , 找不到就是没有. 这种方式简单 , 可简单 , 并不快!  怎么样让查找更快呢?最好是不采用比较的...
查找算法【哈希表】 - 处理冲突的方法：开放地址法-线性探测法
谢谢你们的关注
10-21 1万+
查找算法【哈希表】 - 处理冲突的方法：开放地址法-线性探测法
28、哈希表（Hash）的查找
hopegrace的博客
03-03 1422
一、哈希表相关概念 1、哈希函数的基本概念 哈希表又称散列表。 哈希表存储的基本思想是：以数据表中的每个记录的关键字k为自变量，通过一种函数H(k)计算出函数值。把这个值解释为一块连续存储空间（即数组空间）的单元地址（即下标），将该记录存储到这个单元中。在此称该函数H为哈希函数或散列函数。按这种方法建立的表称为哈希表或散列表。 理想情况下，哈希函数在关键字和地址之间建立了一个一一对应关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

“翎羽”

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值