哈希表的C语言实现

最新推荐文章于 2024-06-12 16:00:39 发布
最新推荐文章于 2024-06-12 16:00:39 发布
阅读量833 收藏 23
点赞数 28
文章标签： 散列表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingCSUN/article/details/139095088
版权

哈希表的具体原理，参考：

算法数据结构基础——哈希表（Hash Table）-CSDN博客

接下来是我的c语言编程实现：

首先，定义哈希表的节点这个结构体：

// 哈希表的节点结构
typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

        这个结构体的名字是HashNode，结构体成员，key用于存储节点的键；value用于存储与键关联的值；struct HashNode* next;这条指令定义了一个指向 HashNode 类型结构体的指针，名为 next。
        这个指针的作用是：用链地址法来处理哈希冲突，next指针用于链接下一个节点，形成一个链表。这样，当多个键key被哈希函数映射到同一个位置时，可以将这些键值对存储在同一个链表中。

定义哈希表的结构体：

typedef struct {
    HashNode** table;
    int size;
} HashTable;

        这段代码中用typedef关键字定义了哈希表的结构体。结构体的名称是： HashTable

        代码：HashNode** table;定义了一个指针数组table，用于存储哈希表中各个桶的头指针。每个桶可以看作是一个链表的头节点，存储哈希表中所有散列到该桶中的键值对。

        size是一个整数，表示哈希表的大小，即哈希表中的桶的数量。

创建哈希表：

//创建哈希表
HashTable* createHashTable(int size)
{
	HashTable* hashTable = (HashTable*)malloc(sizeof(HashTable));
	hashTable->size = size;
	hashTable->table = (HashNode**)malloc(sizeof(HashNode*) * size);
	for (int i = 0; i < size; i++)
	{
		hashTable->table[i] = NULL;
	}
	return hashTable;
}

        上述代码用于创建并初始化一个哈希表。首先，这个函数的返回类型是HashTable*，表示要求返回一个指向HashTable结构体的指针。size表示哈希表的大小，也就是哈希表中桶的数量。

        后续代码作用就是：分配哈希表结构体的内存，并且设置哈希表的大小，分配桶数组内存，初始化桶数组，每一个桶初始指向为NULL。

哈希函数：

// 哈希函数
int hashFunction(HashTable* hashTable, int key)
{
	return abs(key) % hashTable->size;
}

        这段代码的作用是编写了一个哈希哈数，也就是哈希表的映射函数。这个哈希函数的映射方式是：abs(key) % hashTable。将键的绝对值映射到哈希表的索引范围内。通过取模运算，可以确保返回的哈希值在 0 到 hashTable->size - 1 的范围内。

        这个哈希函数用于将一个整数键映射到哈希表中的一个桶（bucket）索引。哈希函数的作用是将输入的键转换为哈希表的一个有效索引，确保不同的键尽可能均匀地分布在哈希表中。

        举例说明，假如一个哈希表的大小为10，则计算几个不同的键值的哈希值如下：

Key: 15, Hash Value: 5
Key: -7, Hash Value: 7
Key: 3, Hash Value: 3
Key: -11, Hash Value: 1
Key: 27, Hash Value: 7

插入哈希表：

//插入哈希表
void insert(HashTable* hashTable, int key, int value)
{
	int hashIndex = hashFunction(hashTable, key);
	HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
	newNode->key = key;
	newNode->value = value;
	newNode->next = hashTable->table[hashIndex];
	hashTable->table[hashIndex] = newNode;
}

        首先给出函数定义，函数传入的参数是：指向哈希表结构体的指针，要插入的键，要插入的值。

        然后调用hashFunction计算key在哈希表中的哈希值（也就是索引位置，在哪个桶）；

        创建一个新的节点，为新节点的key和value赋值。也是初始化。

        然后处理哈希冲突：将当前桶中的现有节点（可能为空）赋值给新节点的 next 字段；将新节点设置为当前桶的头节点。这一步可以总结为：更新头指针：将新节点插入到桶的头部，使其成为新的头节点。

newNode->next = hashTable->table[hashIndex];
hashTable->table[hashIndex] = newNode;

函数操作解析：

 假设有一个简单的哈希表和三个要插入的键值对：

HashTable: {size: 5, table: [NULL, NULL, NULL, NULL, NULL]}
Insert (key=3, value=10)
Insert (key=8, value=20)
Insert (key=13, value=30)

哈希函数 hashFunction(key) = key % size：

  • Insert (key=3, value=10):

    • hashIndex = 3 % 5 = 3
    • 创建新节点 {key: 3, value: 10, next: NULL}
    • 哈希表更新：table[3] = newNode

  • Insert (key=8, value=20):

    • hashIndex = 8 % 5 = 3
    • 创建新节点 {key: 8, value: 20, next: table[3]}
    • 哈希表更新：table[3] = newNode

  • Insert (key=13, value=30):

    • hashIndex = 13 % 5 = 3
    • 创建新节点 {key: 13, value: 30, next: table[3]}
    • 哈希表更新：table[3] = newNode

最终哈希表结构： 

table:
[NULL, NULL, NULL, {key: 13, value: 30, next: {key: 8, value: 20, next: {key: 3, value: 10, next: NULL}}}, NULL]

查找函数：

//查找哈希表
int search(HashTable* hashTable, int key, int* value)
{
	int hashIndex = hashFunction(hashTable, key);
	HashNode* node = hashTable->table[hashIndex];
	while (node != NULL)
	{
		if (node->key == key)
		{
			*value = node->value;
			return 1;
		}
		node = node->next;
	}
	return 0;
}

        首先通过传入函数的参数key确定要找的值所在的对应的桶，然后在桶中遍历查找是否有相同的key值。遍历步骤是：

  • 遍历链表：从桶的头节点开始，遍历链表中的每个节点。
    • 检查节点键：如果当前节点的键等于查找的键 key：
      • 存储值：将节点的值存储在 value 指向的位置。
      • 返回成功：返回 1 表示找到键。
    • 继续遍历：如果当前节点的键不等于查找的键，移动到下一个节点。
  • 未找到键：如果遍历完整个链表后仍未找到键，返回 0 表示未找到键。

例子：有如下一个哈希表，进行查找操作；

HashTable: {size: 5, table: [NULL, NULL, NULL, {key: 13, value: 30, next: {key: 8, value: 20, next: {key: 3, value: 10, next: NULL}}}, NULL]}
Search key=8
Search key=13
Search key=2

哈希函数 hashFunction(key) = key % size：

  1. 查找 key=8:

    • hashIndex = 8 % 5 = 3
    • 遍历链表：头节点 {key: 13, value: 30, next: ...}
      • 继续遍历：第二个节点 {key: 8, value: 20, next: ...}，找到匹配键。
    • 返回值：找到键，存储值 20，返回 1。

  2. 查找 key=13:

    • hashIndex = 13 % 5 = 3
    • 遍历链表：头节点 {key: 13, value: 30, next: ...}，找到匹配键。
    • 返回值：找到键，存储值 30，返回 1。

  3. 查找 key=2:

    • hashIndex = 2 % 5 = 2
    • 桶 2 为空，直接返回 0。
    • 返回值：未找到键，返回 0。

哈希表删除操作函数：

// 删除哈希表中的节点
void delete(HashTable* hashTable, int key) {
	int hashIndex = hashFunction(hashTable, key);
	HashNode* node = hashTable->table[hashIndex];
	HashNode* prev = NULL;
	while (node != NULL && node->key != key) {
		prev = node;
		node = node->next;
	}
	if (node == NULL) return;  // 未找到键
	if (prev == NULL) {
		hashTable->table[hashIndex] = node->next;
	}
	else {
		prev->next = node->next;
	}
	free(node);
}

        该函数传入的参数是一个哈希表的地址指针，一个要删除的key键。大致流程是首先调用哈希函数根据key找到对应的桶；获取桶的头指针table[hashIndex]，并且用指针node指向这个桶的头指针，初始化一个前驱指针指向为NULL，前驱指针的作用是记录当前节点的前一个节点。然后用while遍历链表查找要删除的节点：

  • 遍历链表：从头节点开始，逐节点检查每个节点的键是否等于 key。
    • 如果 node 为 NULL 或 node->key == key，循环结束。
    • 否则，将 prev 设置为当前节点，将 node 设置为下一个节点。

        如果节点不存在，则直接返回。

        如果目标节点存在，则删除节点。删除节点的方法是：

  • 删除头节点：如果 prev 为 NULL，表示要删除的节点是桶的头节点。
    • 将桶的头指针设置为 node->next。
  • 删除非头节点：如果 prev 不为 NULL，表示要删除的节点不是头节点。
    • 将 prev->next 设置为 node->next，跳过要删除的节点，相当于覆写。

        最终调用free释放目标节点的内存。

例子解析，加入现在有一个哈希表的链表如下：

HashTable: {size: 5, table: [NULL, NULL, NULL, {key: 13, value: 30, next: {key: 8, value: 20, next: {key: 3, value: 10, next: NULL}}}, NULL]}

经过删除函数之后，更新为：

HashTable: {size: 5, table: [NULL, NULL, NULL, {key: 13, value: 30, next: {key: 3, value: 10, next: NULL}}, NULL]}

释放哈希表函数：

// 释放哈希表
void freeHashTable(HashTable* hashTable) {
	for (int i = 0; i < hashTable->size; i++) {
		HashNode* node = hashTable->table[i];
		while (node != NULL) {
			HashNode* temp = node;
			node = node->next;
			free(temp);
		}
	}
	free(hashTable->table);
	free(hashTable);
}

        这个函数的参数是一个指向哈希表的指针。函数内容是：首先遍历这个哈希表的每一个桶，然后利用while释放桶中的每一个节点：

  • 遍历链表：使用 while 循环遍历当前桶中的每个节点。
    • 保存当前节点：temp 保存当前节点的指针。
    • 移动到下一个节点：将 node 指针移到下一个节点。
    • 释放当前节点：使用 free(temp) 释放当前节点的内存。

        最后释放桶数组，释放哈希表结构体。

主函数

接下来是利用哈希表完成的子函数和主函数：


// 两数之和函数实现
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
	HashTable* hashTable = createHashTable(numsSize);
	int* result = (int*)malloc(2 * sizeof(int));
	*returnSize = 0;

	for (int i = 0; i < numsSize; i++) {
		int complement = target - nums[i];
		int complementIndex;
		if (search(hashTable, complement, &complementIndex)) {
			result[0] = complementIndex;
			result[1] = i;
			*returnSize = 2;
			freeHashTable(hashTable);
			return result;
		}
		insert(hashTable, nums[i], i);
	}

	free(result);
	freeHashTable(hashTable);
	return NULL;
}

int main() {
	int nums[] = { 2, 7, 11, 15 };
	int numsSize = sizeof(nums) / sizeof(nums[0]);
	int target = 9;
	int returnSize;
	int* result = twoSum(nums, numsSize, target, &returnSize);

	if (result != NULL) {
		printf("Indices: %d, %d\n", result[0], result[1]);
		free(result);
	}
	else {
		printf("No solution found\n");
	}

	return 0;
}

        本文结合C语言代码说明一个简单的哈希表的代码实现和原理解析。

Anhic
关注
  • 28
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈希排序c语言源代码,分享一个简单高效的哈希表C语言实现
weixin_28677451的博客
05-22 735
hashtable是一种非常实用的数据结构，尤其数据量相当大的时候，当然其中很关键的一点是hash算法。之前看redis数据库源码它里面实现hash的算法为murmurhash3，后来发现了这个xxhash。它的hash速度要比前者更快，而且散列效果也同样相当出色，当然此算法也有不足之处：64位hash只在64位程序跑很快，而且代码相比前者代码多，所以我基于此hash算法尝试写了一个hashtab...
哈希表的C语言链表实现
weixin_46201756的博客
11-23 1771
使用C语言，初步实现了哈希表，使用“链表”的方法，Hash函数是直接“取模”运算
C语言实现哈希表
qq_57907966的博客
04-29 513
【代码】C语言实现哈希表。
哈希表C语言实现详解
hurryddd
12-29 2914
目录 1、数据结构 2、操作函数声明 3、具体实现 1、数据结构 #define HASH_TABLE_MALLOC(size) rt_malloc(size); #define HASH_TABLE_REALLOC(p,size) rt_realloc(p,size); #define HASH_TABLE_CALLOC(n,size) rt_calloc(n,size); ...
c语言实现哈希表
tjh1998的博客
04-28 7529
哈希表
C语言哈希表实现
m0_48995611的博客
05-24 778
本文提供一种C语言HASH表的实现方法，包括插入、删除、查找操作。
C语言算法基础——哈希表的实现
weixin_52109967的博客
07-24 7435
菜鸟日常学习算法的总结！
C语言实现简单哈希表
weixin_45292180的博客
01-06 5348
什么是哈希表 哈希表，也叫散列表，是根据关键码值而直接进行访问的数据结构。通俗点说，就是通过关键值(key)映射到表中的某个位置，以便可以直接访问该节点，以提高查找速度。这个映射函数就是散列函数。 举个例子，我们有很多员工的信息需要存储，比如张三，李四，王五；一般来说我们可以用链表将他们的信息存储起来，当我们需要某个员工的信息时，遍历链表查找出其信息即可。这样的弊端可想而知：查找效率太低。而如果我们有个函数f(x)，能将张三，李四，王五分别映射成1，2，3。那我们可以直接将张三，李四，王五的信息分别存储在链
用C语言实现哈希表HashMap
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
01-14 1060
用C语言，基于动态数组+链表的形式实现的的HashMap
哈希表C语言实现
m0_37742918的博客
03-03 307
哈希表 #include <stdio.h> #include "stdlib.h" #define HASHSIZE 12 /*定义哈希表长为数组的长度*/ #define NULLKEY -32768 // 定义哈希表 (使用的是动态数组来进行保存） typedef struct HashTable { int len; int *elem; }HashTable; // 初始化哈希表 int initHashTable(HashTable *hashTable)
哈希表实验C语言版实现
09-05
以下是对哈希表实验用C语言实现的代码进行了详细的分析介绍，需要的朋友可以参考下
C语言基于哈希表实现通讯录
08-27
主要为大家详细介绍了C语言基于哈希表实现通讯录，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
cpp-jwHash简单的哈希表C语言实现
08-16
jwHash - 简单的哈希表C语言实现
C语言设计哈希表实现图书查找
10-26
C语言设计哈希表实现图书查找系统，完成相应的建表和查表程序。从键盘输入各图书相关信息，分别以图书编号为关键字建立散列表。待填入哈希表的书号至少30个；构造合适的哈希函数。 1） 记录由外部输入。 2） 将生成...
数据结构——哈希表
qq_61350148的博客
06-08 824
使用java语言实现《数据结构——哈希表》。
数据结构 -＞反转链表
最新发布
2401_83373946的博客
06-12 222
这个函数使用迭代的方法反转了一个单向链表。通过逐个节点的处理，将每个节点的next指针反转，最终得到反转后的链表。
【数据结构】单链表（C语言）
2402_82689232的博客
06-12 951
本篇文章介绍的单链表的基础概念及结构实现
【数据结构】双链表
weixin_73483158的博客
06-11 464
带头双向循环链表。
从零开始学数据结构系列之第三章《二叉树链式结构及实现2》
铁匠匠匠的博客
06-09 1012
​   根遍历的原理就是，​   一句话来讲，就是。所以我们按如上顺序来算的话。
哈希表c语言实现代码
12-13
以下是一个简单的哈希表C语言实现代码，使用链地址法解决哈希冲突： ```c #include #include #include #define HASHSIZE 12 #define NULLKEY -32768 typedef struct { int *elem; // 数据元素存储基址，动态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值