哈希结构（散列表）

于 2024-02-02 20:28:58 发布
阅读量936 收藏 20
点赞数 18
分类专栏： 算法基础复习 文章标签： 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69767208/article/details/135997512
版权

数据结构之哈希

什么是哈希

哈希结构（Hash Table）也被称为散列表，是一种用于实现字典（Dictionary）的数据结构。哈希结构将键（Key）映射到值（Value）的过程称为哈希（Hashing），哈希函数（Hash Function）用于将键映射到一个固定大小的数组（Hash Table），数组中的每个元素称为桶（Bucket），每个桶可以存储一个或多个键值对。哈希结构的主要优点是可以在常数时间内进行插入、查找和删除操作，因此在大多数情况下，哈希结构的操作效率非常高。

哈希构造函数

哈希构造函数（Hash Constructor）是哈希结构中的一种函数，用于将键（Key）映射到哈希表中的位置。哈希构造函数通常是一个确定性函数，即对于相同的键，哈希构造函数总是返回相同的哈希值。哈希构造函数的设计非常关键，它直接影响哈希结构的查找、插入和删除等操作的效率。

哈希构造函数的设计需要满足以下几个要求：

  • 一致性：对于相同的键，哈希构造函数应该总是返回相同的哈希值。

  • 均匀性：哈希构造函数应该尽可能均匀地将键映射到哈希表中的位置，以避免哈希冲突。

  • 高效性：哈希构造函数的计算时间应该尽可能短，以提高哈希结构的操作效率。

哈希构造函数的设计方法有很多种，常见的方法包括：

  • 直接寻址法（Direct Addressing）：将键直接作为哈希表中的位置，适用于键的范围比较小的情况。

  • 除留余数法（Division Method）：将键除以一个不大于哈希表大小的质数，然后取余数作为哈希值。

  • 乘法哈希法（Multiplicative Hashing）：将键乘以一个常数A（0<A<1），然后取乘积的小数部分乘以哈希表大小作为哈希值。

  • 一次探测法（Linear Probing）：当发生哈希冲突时，依次向后探测空桶，直到找到空桶或者遍历整个哈希表。

  • 双重哈希法（Double Hashing）：使用两个不同的哈希函数，当发生哈希冲突时，依次使用两个哈希函数计算出新的哈希值，直到找到空桶或者遍历整个哈希表。

选择合适的哈希构造函数需要考虑键的特点、哈希表的大小、哈希冲突的处理方法等因素，通常需要进行实验和分析来确定最优的哈希构造函数。

哈希冲突

哈希冲突（Hash Collision）指的是不同的键（Key）被哈希构造函数映射到了哈希表中的同一个位置，导致这些键在哈希表中发生了冲突。哈希冲突是哈希结构中的一个常见问题，如果不能很好地处理哈希冲突，就会导致哈希表的操作效率下降，甚至无法正常工作。

哈希冲突的发生是由于哈希构造函数的设计不够均匀，或者键的数量太多，而哈希表的大小又不够大。当哈希冲突发生时，需要采取一定的处理方法，以解决哈希冲突。常见的哈希冲突处理方法包括：

  • 链表法（Chaining）：将哈希表中的每个桶改为一个链表，当发生哈希冲突时，将新的键值对插入到链表的末尾。

  • 开放地址法（Open Addressing）：当发生哈希冲突时，依次向后探测空桶，直到找到空桶或者遍历整个哈希表。

  • 再哈希法（Rehashing）：当哈希冲突发生时，使用另一个哈希函数计算出新的哈希值，然后将键值对插入到新的哈希表中。

选择合适的哈希冲突处理方法需要考虑具体的应用场景和数据特点，通常需要进行实验和分析来确定最优的处理方法。

数组哈希图示

  • 数组存储

  • 取余法哈希函数

  • 开放地址法处理冲突

 

散列存储图示

  • 链表存储

  • 取余法哈希函数

  • 链表法处理冲突

 

使用数组实现哈希表

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

//没有键的数据可以构建一个键处理
typedef struct pair //键的数据和键值
{
	int key;
	char str[20];
}Data;

typedef struct HashTable //创建哈希表
{
	Data** table;//用二级指针方便赋初值，没有的话直接置为空
	int divisor;    //h(key)=key%p
	int count;
}Hash;
Hash* create_hash(int p) //传入总长度
{
	Hash* hash = (Hash*)calloc(1, sizeof(Hash));//创建并初始化为0
	assert(hash);
	hash->divisor = p;
	hash->count = 0;
	hash->table = (Data**)calloc(hash->divisor, sizeof(Data*));
	assert(hash->table);
	return hash;
}
int get_hash(Hash* hash, int key) //获取哈希地址
{
	int pos = key % hash->divisor;
	int curPos = pos;//哈希的键值
	do
	{
		if (hash->table[curPos] == NULL || hash->table[curPos]->key == key) //哈希表该位置数据为空，或者数据相同
		{
			return curPos;
		}
		curPos = (curPos + 1) % hash->divisor;
	} while (pos != curPos);//没有返回到自身
	return curPos;//返回自身值 （转了一圈没有空位）
}
void push_hash(Hash* hash, Data data) //入栈
{
	int pos = get_hash(hash, data.key);
	if (hash->table[pos] == NULL) //为空
	{
		hash->table[pos] = (Data*)calloc(1, sizeof(Data));
		memcpy(hash->table[pos], &data, sizeof(Data));//空数据进行内存申请
		hash->count++;
	}
	else 
	{
		if (hash->table[pos]->key == data.key) //建相同进行覆盖
		{
			strcpy_s(hash->table[pos]->str, 20, data.str);
		}
		else //键是满的 
		{
			printf("Hash is Full\n");
			return;
		}
	}
}
void print_hash(Hash* hash) 
{
	for (int i = 0; i < hash->divisor; i++) 
	{
		if (hash->table[i] == NULL) 
		{
			printf("%d:NULL\n",i);
		}
		else 
		{
			printf("%d:[%d,%s]\n", i, hash->table[i]->key, hash->table[i]->str);
		}
	}
}
int search_hash(Hash* hash, int key)
{
	int pos = key % hash->divisor;
	int curPos = pos;
	do
	{
		if (hash->table[curPos] == NULL) 
		{
			return -1;
		}
		else if (hash->table[curPos]->key == key) 
		{
			return curPos;
		}
		curPos = (curPos + 1) % hash->divisor;
	} while (pos != curPos);
	return -1;
}
int main() 
{
	Hash* hash = create_hash(10);
	Data arr[7] = { 1,"小美",11,"小芳",25,"小小",46,"baby",78,"花花",25,"coco",21,"明明"};
	for (int i = 0; i < 7; i++) 
	{
		push_hash(hash, arr[i]);
	}
	print_hash(hash);
	int result = search_hash(hash,1);
	printf("result:%d\n", result);
	result = search_hash(hash, 11);
	printf("result:%d\n", result);
	result = search_hash(hash, 21);
	printf("result:%d\n", result);
	result = search_hash(hash, 31);
	printf("result:%d\n", result);

	return 0;
}

链表哈希实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
typedef struct pair 
{
	int key;
	char str[20];
}Data;

//横向链表
typedef struct Node 
{
	Data data;
	struct Node* next;
}Node;

Node* create_node(Data data) 
{
	Node* newNode = (Node*)calloc(1, sizeof(Node));
	assert(newNode);
	newNode->data = data;
	return newNode;
}
//纵向链表 （存储键值相同的）
typedef struct SkipListNode 
{
	Data data;
	Node* headNode;
	struct SkipListNode* next;
}SNode;

SNode* create_snode(Data data) //纵向链表结构创建
{
	SNode* newNode = (SNode*)calloc(1, sizeof(SNode));
	assert(newNode);
	newNode->data = data;
	return newNode;
}

//hash结构
typedef struct HashTable 
{
	SNode* headNode;
	int count;
	int divisor;
}Hash;

enum Type {No,SKips,Nodes};
typedef struct smatch
{
	enum Type flag;    //false: snode true=node
	union 
	{
		Node* p;
		SNode* ps;
	};
}smatch;


Hash* create_hash(int p) 
{
	Hash* hash = (Hash*)calloc(1, sizeof(Hash));
	assert(hash);
	hash->divisor = p;
	return hash;
}
void push_hash(Hash* hash,Data data)
{
	int pos = data.key % hash->divisor;
	SNode* snode = create_snode(data);
	if (hash->headNode == NULL) 
	{
		hash->headNode = snode;
		hash->count++;
	}
	else 
	{
		SNode* pmove = hash->headNode;
		SNode* premove = NULL;
		//1.插入数据的哈希地址小于头节点
		if (pmove->data.key % hash->divisor > pos) 
		{
			//无表头链表的表头法插入
			snode->next = hash->headNode;
			hash->headNode = snode;
			hash->count++;

		}
		else 
		{
			//找第一次大于或者等于插入数据的哈希地址
			while (pmove != NULL && ((pmove->data.key % hash->divisor) < pos)) 
			{
				premove = pmove;
				pmove = premove->next;
			}
			//分析退出循环结果
			if (pmove != NULL && ((pmove->data.key % hash->divisor) == pos)) 
			{
				//存在冲突
				if (pmove->data.key == data.key) 
				{
					//覆盖的方式处理键是一样的数据
					strcpy_s(pmove->data.str, 20, data.str);
				}
				else 
				{
					//横向链表
					Node* newNode = create_node(data);
					Node* ppmove = pmove->headNode;
					if (ppmove == NULL) 
					{
						//插入节点成为新表头
						newNode->next = pmove->headNode;
						pmove->headNode = newNode;
						hash->count++;
					}
					else 
					{
						//检查横向链表是否存在相同键的数据
						while (ppmove != NULL && ppmove->data.key != data.key) 
						{
							ppmove = ppmove->next;
						}
						if (ppmove == NULL) 
						{
							//插入节点成为新表头
							newNode->next = pmove->headNode;
							pmove->headNode = newNode;
							hash->count++;
						}
						else 
						{
							strcpy_s(ppmove->data.str, 20, data.str);
						}
					}
				}
			}
			else 
			{
				//不存在冲突直接连接到纵向链表中即可
				premove->next = snode;
				snode->next = pmove;
				hash->count++;
			}
		}
	}
}
void print_hash(Hash* hash) 
{
	SNode* pmove = hash->headNode;
	while (pmove != NULL) 
	{
		printf("[%d,%s]:\t", pmove->data.key, pmove->data.str);
		Node* ppmove = pmove->headNode;
		while(ppmove!=NULL)
		{
			printf("[%d,%s]\t", ppmove->data.key, ppmove->data.str);
			ppmove = ppmove->next;
		}
		printf("\n");
		pmove = pmove->next;
	}
}

int size_hash(Hash* hash) 
{
	return hash->count;
}
bool empty_hash(Hash* hash) 
{
	return hash->count == 0;
}
smatch search_hash(Hash* hash, int key) 
{
	smatch result = {0};
	if (hash == NULL)
		return result;
	SNode* pmove = hash->headNode;
	int pos = key % hash->divisor;
	while (pmove != NULL && (pmove->data.key%hash->divisor) != pos) 
	{
		pmove = pmove->next;
	}
	if (pmove == NULL)
		return result;
	else 
	{
		if (pmove->data.key == key)
		{
			result.flag = SKips;
			result.ps = pmove;
			return result;
		}
		else 
		{
			Node* ppmove = pmove->headNode;
			while (ppmove != NULL && ppmove->data.key != key)
			{
				ppmove = ppmove->next;
			}
			if (ppmove == NULL) 
			{
				return  result;
			}
			else 
			{
				result.flag = Nodes;
				result.p = ppmove;
				return result;
			}
		}
	}
}
void print_result(smatch data) 
{
	switch (data.flag) 
	{
	case No:
		printf("未找到指定数据!\n");
		break;
	case SKips:
		printf("[%d,%s]\n", data.ps->data.key, data.ps->data.str);
		break;
	case Nodes:
		printf("[%d,%s]\n", data.p->data.key, data.p->data.str);
		break;
	}
}
int main() 
{
	Hash* hash = create_hash(10);
	Data arr[10] = { 1,"小美",11,"小芳",25,"小小",46,"baby",78,"花花",
		25,"coco",21,"明明",11,"妹妹",56,"小爱",45,"小雪"};
	for (int i = 0; i < 10; i++)
	{
		push_hash(hash, arr[i]);
	}
	print_hash(hash);

	printf("----------------------\n");
	smatch result = search_hash(hash, 46);
	print_result(result);
	print_result(search_hash(hash, 11));
	return 0;
}

m0_69767208
关注
  • 18
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性表——散列存储结构——哈希表知识点总结
MISAYAONE的博客
05-14 1万+
散列(hashing)是一种重要的存储方法，也是一种常见的查找方法。 基本思想：以结点的关键字k为自变量，通过一个确定的函数关系f，计算出对应的函数值，吧这个函数值解释为结点的存储地址，将结点存入到f(k)所指示的存储位置上，在查找时再根据要查找的关键字，用同样的函数计算地址，然后到相应的单元中读取。散列法又被成为关键字——地址转换法。 顺序表的特点是：寻址容易，插入和删除困难
Hash表（哈希表、散列表）
CairBin的博客
11-22 4387
哈希表，也叫散列表，英文Hash table，是根据关键码值而直接进行访问的数据结构。
详解--Hash（中文也称散列、哈希）
qq_37233070的博客
11-07 2259
Hash 也称散列、哈希，对应的英文都是 Hash。基本原理就是把任意长度的输入，通过 Hash 算法变成固定长度的输出。这个映射的规则就是对应的 Hash 算法，而原始数据映射后的二进制串就是哈希值。hash 算法理论上会出现 不同数据通过 hash 算法计算出相同的 hash 值，叫做碰撞。活动开发中经常使用的 MD5 和 SHA 都是历史悠久的 Hash 算法。好的 hash 算法至少应计算 hash 值迅速且hash 值冲突概率要小。两个知识抗碰撞能力。
数据结构学习:哈希表
nzbing的博客
05-29 220
哈希表一、概念二、散列函数三、散列冲突四、代码实现 一、概念 哈希(Hash)表又称为散列表,是利用数组支持按照下标随机访问的特性,是数组的一种扩展,可以说没有数组就没有哈希表 哈希表存储键值对,key由某个散列函数转化成数组的下标,通过key访问相当于通过数组下标访问 可以知道数组支持下标随机访问的时间复杂度是O(1),但是为了维护连续内存空间,插入和删除的时间复杂度退化到O(n);但散列表随机访问的时间复杂度正常情况下是O(1),同时不用维护连续内存空间,插入和删除的时间复杂度也为O(1) 二、散列
哈希表详解
M120674的专栏
12-07 461
哈希表是个啥？ 小白： 庆哥，什么是哈希表？这个哈希好熟悉，记得好像有HashMap和HashTable之类的吧，这是一样的嘛？???? 庆哥： 这个哈希确实经常见????，足以说明它是个使用非常频繁的玩意儿，而且像你说的HashMap和HashTable之类的与哈希这个词肯定是有关系的，那哈希是个啥玩意啊，这个咱们还是得先来搞明白啥是个哈希表。???? 我们看看百科解释吧： 散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于
数据结构 - 哈希表（散列表）
gghhb12的博客
04-23 3140
数据结构 - 哈希表（散列表）
哈希表（散列表）原理详解 - CSDN博客1
08-03
哈希表，又称散列表，是一种高效的数据存储和查找结构，其主要原理是通过散列函数将关键码值（Key value）映射到一个固定大小的数组中的特定位置，从而实现快速访问。这个映射过程使得我们可以直接根据键（Key）来...
用散列表写的通讯录管理系统
04-14
散列表是通过哈希函数将数据映射到一个固定大小的数组中的数据结构。这个哈希函数可以将任意长度的键（如姓名）转化为固定长度的索引，使得我们能在常数时间复杂度内完成查找、插入和删除操作。这种特性对于通讯录...
数据结构课程设计 学生信息管理系统哈希表学号 姓名查询
02-10
2.按照学号字段建一个哈希表，实现按学号进行查找 务必用哈希结构实现 3.按照姓名字段构建哈希表结构，实现姓名的模糊查询。姓名取中文姓氏作为哈希地址 4.排序 实现多关键字排序 5.分别使用堆排和快排显示成绩前10...
散列表与散列冲突
01-08
HashTable，音译为哈希表，是根据关键字（key）而直接进行访问的数据结构。关键字k，值存放在f(k)的存储位置上，则f为散列函数。关键字（key）通过散列函数直映射到表中一个位置，以加快查找速度。 散列冲突，因为...
哈希表的数据结构
06-29
哈希表的数据结构哈希表的数据结构哈希表的数据结构哈希表的数据结构
基于哈希表的图书馆管理系统（数据结构）
05-26
主要用到数据结构中的哈希表，使用文件IO的操作设计了一个图书管理系统，系统分为分有一个主界面和多个子界面，实现后的效果可以界面切换自如，子界面中设计有学生入口以及老师入口，分别模拟不同的操作，功能都是...
数据结构——哈希表
zhaohong_bo的专栏
05-16 713
mark，后续完成 https://blog.csdn.net/snailmann/article/details/80435311
数据结构------哈希表
未知性别程序员的博客
03-17 405
哈希表 哈希表(Hash Table,又称散列表),是一种线性表的存储结构.哈希表有一个直接寻址地址和一个哈希函数组成.哈希函数h(k)将元素关键字k作为自变量,返回元素的存储下标 过程 直接寻址表 当关键字的全域U比较小时,直接寻址是一种简单而有效的方法 缺点: 当域U很大时,需要消耗大量的内存,很不实际, 如果U很大而实际出现的key很少,则大量的空间被浪费. 无法处理关键字不是数字的情况. 改进直接寻址法—哈希 (1)构建大小为m的寻指标T; (2)key为k的元素放在h(k)位置上; (3)h(k)
数据结构---哈希表
BEYONDmonster的博客
10-10 431
哈希表属于一种数据结构，而不是一种算法。 哈希表也叫散列表，是根据关键码值而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 散列表：数组和链表相结合，将链表存放到数组中。 将数据存放到结点中，由结点组成链表。 根据散列函数确定数据放在哪个链表中。 Java代码具体实现： import java....
Map接口下的集合
weixin_45818037的博客
05-21 243
HashMap1.HashMap1.1特点1.2 哈希冲突1.3HashMap实现原理1.3.1几个重要字段1.3.2 Hash函数1.3.3 返回数组下标1.3.4 扩容1.3.5 数组的长度一定是 2 次幂1.3.6 put方法1.3.7 remove 方法1.3.8 get方法1.4 缺点2.LinkedHashMap3.TreeMap3.1 **HashMap与TreeMap的区别：**3.2 **时间复杂度：**3.3 TreeMap 底层数据结构3.4 比较器 1.HashMap 1.1特点 首
详解哈希数据结构，手写哈希表
CRMEB小程序商城的博客
10-18 6025
哈希表，终于姗姗来迟了。 本文系统讲解了哈希表数据结构的相关概念，并以HashMap为案例讲解一下它与普通哈希表的不同点，最后也手写一个简易的哈希表。 所以通过本文，我希望读者们能对哈希表有一个清楚的认识，尤其是在Java面试过程中，HashMap的相关面试题几乎是逢面必问，如果你连哈希表结构都不清楚，那真的很难从根上理解HashMap。 除了面试，在你掌握了哈希表之后也可以根据应用场景的需要，对哈希函数进行重写，以此来保证在你的应用场景下哈希分布的更加均匀。 本文概览如下： 哈希表 散列表（Hash
数据结构之哈希表
猎户星座
02-24 1367
Hash表也称散列表，也有直接译作哈希表，Hash表是一种根据关键字值（key - value）而直接进行访问的数据结构。它基于数组，通过把关键字映射到数组的某个下标来加快查找速度，但是又和数组、链表、树等数据结构不同，在这些数据结构中查找某个关键字，通常要遍历整个数据结构，也就是O(N)的时间级，但是对于哈希表来说，只是O(1)的时间级。 　　注意，这里有个重要的问题就是如何把关键字转换为数组的下标，这个转换的函数称为哈希函数（也称散列函数），转换的过程称为哈希化。 1、哈希函数的引入 大家都用过字
散列表和哈希表的关系
最新发布
03-26
散列表和哈希表是两个相关的概念，它们之间存在一定的关系。 散列表（Hash Table）是一种数据结构，用于实现键值对的存储和查找。它通过将键映射到一个固定大小的数组索引来实现高效的查找操作。散列表的核心思想是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值