C语言实现hashMap

最新推荐文章于 2024-05-22 07:00:00 发布
最新推荐文章于 2024-05-22 07:00:00 发布
阅读量1.6w 收藏 16
点赞数 1
分类专栏： 学习之旅 文章标签： 数据结构 哈希表 C 链表 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
版权

图中，紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

 

下载链接：https://download.csdn.net/download/sxf1061700625/13101710

供参考学习

hashMap.h

#ifndef _HASHMAP_H
#define _HASHMAP_H

typedef struct HashNode
{
    char* key;
    char* value;
    struct HashNode* next; // 当key相同时，指向集合中的下一个节点
}HashNode;

typedef struct
{
    int size; // hash map不重复node的数量
    HashNode** hashArr; // 二维数组，存key值不重复的node，key重复的node链接在HashNode->next
}HashMap;


HashMap* CreateHashMap(int n);
int InsertHashMap(HashMap* hashMap, char* key, char* value);
char* GetHashMap(HashMap* hashMap, char* key);
void DeleteHashMap(HashMap* hashMap);
int RemoveHashMap(HashMap* hashMap, char* key);
void PrintHashMap(HashMap* hashMap);
void hashMapTest(void);


#endif

hashMap.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "hashUtil.h"
#include "hashMap.h"

#define myMalloc  malloc // 使用哪个malloc函数
#define myCalloc  calloc // 使用哪个calloc函数
#define myFree    free   // 使用哪个free函数
#define myHash    hash   // 使用哪个hash函数

// https://i-blog.csdnimg.cn/blog_migrate/3599ddbb8629a9ff7ecfb3f2eb2dd976.png
// 图中，紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

// 有些如STM32就不自带strdup函数
#if !HAVE_STRDUP
#undef strdup
char *strdup(const char *s)
{
	size_t len = strlen(s) + 1;//计算字符串的长度
	void *new = malloc(len);//分配一个新的空间给new
	if(new == NULL) return NULL;
	return (char *)memcpy(new, s, len);//拷贝s数据到new中
}
#endif


/**
 * @description: 创建一个node数量为n的hash表
 * @param {n}    node数量
 * @return {*}   创建的hash map
 */
HashMap* CreateHashMap(int n)
{
    HashMap* hashMap = (HashMap*)myCalloc(1, sizeof(HashMap));
    hashMap->hashArr = (HashNode**)myCalloc(n, sizeof(HashNode*));
    if (hashMap==NULL || hashMap->hashArr==NULL) {
        return NULL;
    }
    hashMap->size = n;
    return hashMap;
};

/**
 * @description:     插入1个键值对
 * @param {*hashMap} 待操作的hash表
 * @param {*key}     键
 * @param {*value}   值
 * @return {int}     是否操作成功，0:失败；1:成功
 * @attention 如果key相同，则后插入的value会覆盖已有的value
 */
int InsertHashMap(HashMap* hashMap, char* key, char* value)
{
    // 创建一个node节点
    HashNode* node = (HashNode*)myCalloc(1, sizeof(HashNode));
    if (node == NULL) {
        return 0;
    }
    
    // 复制键和值
    node->key = strdup(key);
    node->value = strdup(value);
    node->next = NULL;
    // 对hash结果求余，获取key位置
    int index = myHash(key) % hashMap->size;
    // 如果当前位置没有node，就将创建的node加入
    if (hashMap->hashArr[index] == NULL) {
        hashMap->hashArr[index] = node;
    }
    // 否则就要在已有的node往后添加
    else {
        // 用于遍历node的临时游标
        HashNode *temp = hashMap->hashArr[index];
        // 记录上一个node
        HashNode *prev = temp;
        // 循环遍历至最后一个节点node_end的next
        while (temp != NULL) {
            // 如果两个key相同，则直接用新node的value覆盖旧的
            if (strcmp(temp->key, node->key) == 0) {
                // 释放旧value
                myFree(temp->value);
                // 复制新value
                temp->value = strdup(node->value);
                return 1;
            }
            prev = temp;
            temp = temp->next;
        }
        // 最后一个节点node_end的next指向新建的node
        prev->next = node;
    }
    return 1;
}

/**
 * @description:     通过key查找value
 * @param {*hashMap} 待操作的hash表
 * @param {*key}     通过key找对应的value
 * @return {*}       找到的value
 */
char* GetHashMap(HashMap* hashMap, char* key)
{
    // 对hash结果求余，获取key位置
    int index = myHash(key) % hashMap->size;
    // 用于遍历node的临时游标
    HashNode *temp = hashMap->hashArr[index];
    // 循环遍历至最后一个节点node_end的next
    while (temp != NULL) {
        // 如果两个key相同，则用新node的value覆盖旧的
        if (strcmp(temp->key, key) == 0) {
            return temp->value;
        }
        temp = temp->next;
    }
    return NULL;
}

/**
 * @description:     释放hash map内存
 * @param {*hashMap} 待操作的hash表
 * @return {}
 */
void DeleteHashMap(HashMap* hashMap)
{
    for (int i = 0; i < hashMap->size; i++)
    {
        // 用于遍历node的临时游标
        HashNode *temp = hashMap->hashArr[i];
        HashNode *prev = temp;
        // 循环遍历至最后一个节点node_end的next
        while (temp != NULL) {
            prev = temp;
            temp = temp->next;
            myFree(prev->key);
            myFree(prev->value);
            myFree(prev);
        }
    }
    myFree(hashMap->hashArr);
    myFree(hashMap);
    hashMap->hashArr = NULL;
    hashMap = NULL;
}

/**
 * @brief 删除由key指定的键值对
 * @param hashMap 待操作的hash表
 * @param key 
 * @return
 */
int RemoveHashMap(HashMap* hashMap, char* key)
{
    // 对hash结果求余，获取key位置
    int index = myHash(key) % hashMap->size;
    // 用于遍历node的临时游标
    HashNode *temp = hashMap->hashArr[index];
    if (temp == NULL) {
        return 0;
    }
    
    // 如果第一个就匹配中
    if (strcmp(temp->key, key) == 0) {
        // printf("找到:%s->%s\n", temp->key, temp->value);
        hashMap->hashArr[index] = temp->next;
        myFree(temp->key);
        myFree(temp->value);
        myFree(temp);
        return 1;
    }else {
        HashNode *prev = temp;
        temp = temp->next;
        // 循环遍历至最后一个节点node_end的next
        while (temp != NULL) {
            // 如果两个key相同，则用新node的value覆盖旧的
            if (strcmp(temp->key, key) == 0) {
                // printf("找到:%s->%s\n", temp->key, temp->value);
                prev->next = temp->next;
                myFree(temp->key);
                myFree(temp->value);
                myFree(temp);
                return 1;
            }
            prev = temp;
            temp = temp->next;
        }
    }
    return 0;
}

/**
 * @description: 打印hash map
 * @param {*hashMap}
 * @return {}
 */
void PrintHashMap(HashMap* hashMap)
{
    printf("===========PrintHashMap==========\n");
    HashNode* node = NULL;
    for (int i = 0; i < hashMap->size; i++)
    {
        node = hashMap->hashArr[i];
        if (node != NULL) {
            HashNode* temp = node;
            while (temp != NULL) {
                printf("[%d]: %s -> %s\t", i, temp->key, temp->value);
                temp = temp->next;
            }
            printf("\n");
        }
    }
    printf("===============End===============\n");
}

void hashMapTest(void)
{
    HashMap* hashMap = CreateHashMap(5);
    if (hashMap) {
        printf("创建完成\n");
    }
    
    InsertHashMap(hashMap, "a", "a1");
    InsertHashMap(hashMap, "a", "a2");
    InsertHashMap(hashMap, "b", "b1");
    InsertHashMap(hashMap, "b", "b2");
    InsertHashMap(hashMap, "c", "c1");
    InsertHashMap(hashMap, "d", "d1");
    InsertHashMap(hashMap, "e", "e1");
    InsertHashMap(hashMap, "f", "f1");
    InsertHashMap(hashMap, "f", "f1");
    InsertHashMap(hashMap, "g", "g1");
    InsertHashMap(hashMap, "h", "h1");
    PrintHashMap(hashMap);

    int code = RemoveHashMap(hashMap, "a");
    if (code) {
        printf("删除成功\n");
    }
    
    PrintHashMap(hashMap);

    char* res = GetHashMap(hashMap, "g");
    if (res) {
        printf("找到, g -> %s\n", res);
    }
    res = GetHashMap(hashMap, "q");
    if (res == NULL) {
        printf("未找到, q -> %s\n", res);
    }
    
    DeleteHashMap(hashMap);
    printf("销毁完成\n");
}

int main(int argc, char const *argv[])
{
    hashMapTest();
    return 0;
}

hashUtil.h

#ifndef _HASHUTIL_H
#define _HASHUTIL_H

unsigned int hashMysqlNR(const char *key, unsigned int len);
unsigned int hashMysqlNRCaseUp(const char *key, unsigned int len);
unsigned long hashPhp(char *arKey, unsigned int nKeyLength);
unsigned long hashOpenSSL(char *str);
unsigned int hash(char *str);
void hashTest(void);

#endif

hashUtil.c

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "hashUtil.h"

/**
 * MySql中出现的字符串Hash函数
 * 这种哈希是迄今为止我们所见过的所有函数中产生碰撞最少的，对数字和字符串都很有效。
 */
unsigned int hashMysqlNR(const char *key, unsigned int len)
{
    const char *end=key+len;
    unsigned int hash; 

    for (hash = 0; key < end; key++) {
        hash *= 16777619;
        hash ^= (unsigned int) *(unsigned char*) key;
    } 

    return (hash);
} 

/**
 * MySql中出现的字符串Hash函数
 * 计算一个键的哈希值，大小写独立
 */
unsigned int hashMysqlNRCaseUp(const char *key, unsigned int len)
{
    const char *end=key+len;
    unsigned int hash; 

    for (hash = 0; key < end; key++) {
        hash *= 16777619;
        hash ^= (unsigned int) (unsigned char) toupper(*key);
    } 

    return (hash);
}


/**
 * PHP中出现的字符串Hash函数
 */
unsigned long hashPhp(char *arKey, unsigned int nKeyLength)
{
    unsigned long h = 0, g;
    char *arEnd=arKey+nKeyLength; 

    while (arKey < arEnd) {
        h = (h << 4) + *arKey++;
        if ((g = (h & 0xF0000000))) {
            h = h ^ (g >> 24);
            h = h ^ g;
        }
    }
    return h;
}

/**
 * OpenSSL中出现的字符串Hash函数
 */
unsigned long hashOpenSSL(char *str)
{
    int i,l;
    unsigned long ret=0;
    unsigned short *s; 

    if (str == NULL) return(0);
    l=(strlen(str)+1)/2;
    s=(unsigned short *)str; 

    for (i=0; i<l; i++)
    ret^=(s[i]<<(i&0x0f));
    return(ret);
} 

/**
 * 另一个经典字符串Hash函数
 */
unsigned int hash(char *str)
{
    register unsigned int h;
    register unsigned char *p; 

    for(h=0, p = (unsigned char *)str; *p ; p++) {
        h = 31 * h + *p; 
    }

    return h;
}


void hashTest(void)
{
    unsigned long h = hashPhp("ABCabc", 6);
    printf("hashPhp: %ld\r\n", h);              // 72783747

    unsigned int h2 = hashMysqlNR("ABCabc", 6);
    printf("hashMysqlNR: %d\r\n", h2);          // 1403034336

    unsigned int h3 = hashMysqlNRCaseUp("ABCabc", 6);
    printf("hashMysqlNRCaseUp: %d\r\n", h3);    // 860927488
    
    unsigned long h4 = hashOpenSSL("ABCabc");
    printf("hashOpenSSL: %ld\r\n", h4);         // 68943

    unsigned int h5 = hash("ABCabc");
    printf("hash: %d\r\n", h5);                 // 1923939552
}

 

 

 

 

 

 

 

 

 

 

 

小锋学长生活大爆炸
关注
专栏目录
用C语言实现哈希表HashMap
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
01-14 1912
用C语言，基于动态数组+链表的形式实现的的HashMap
C语言的hashmap
mrbone9的博客
03-28 4203
在算法练习当中，常常会遇到用 hashmap 来实现的思路，通过 key-value 方便快捷的查找，增加，删除特定数据。 在高级语言当中，c++或java都有一套 hashmap API可供使用，但是 C 语言却没有系统的 不过开源项目为我们提供了这套工具，利用这套工具，可以方便的将自定义数据结构 hash 话 官网文档： uthashhttps://troydhanson.github.io/uthash/userguide.html#_a_hash_in_c git 仓库 uthash
源码解析系列：HashMap(5) - c语言实现一个HashMap
Jwasx的博客
01-14 1349
文章目录1. 前言2. 开始C语言之旅 1. 前言 HashMap(5)中主要介绍了我的一个数据结构实验课设，而这个课设是实现一个HashMap，政整个HashMap的实现是以java JDK1.8的HashMap为参考实现的，其实说是参考，大部分其中的方法是和java源码一样的，在红黑树的方面则是自己设计的。对于这个课设，也有一些和HashMap不一样的地方，比如Key和Value都是使用int类型的，数组下标不再存放无头单链表，而是存放有头单链表，这其实都是其中一些坑，后来慢慢改成这样的。对于Ha..
C语言实现HashMap
热门推荐
turboMan的博客
07-21 2万+
C语言实现HashMap在做算法题时,需要使用到HashMap提高效率，虽然高级语言中大豆实现了这种数据结构，但是高级语言的效率低，于是打算自己实现HashMap，加深理解，使用C语言实现了HashMap的创建（CreateHashMap）、取1.类型定义如下：typedef struct{ int key; int val; }DataType; typedef s
【算法】【基础数据类型】C语言版本的HashMap实现
qq_39760347的博客
07-20 1065
c语言实现hashmap
c语言实现哈希字典Hashmap
10-14
做项目写业务逻辑的时候经常用到的数据...但是c语言是没有提供这类标准库的，本资源提供的是一个可以在正式项目中使用的纯c语言实现的哈希字典。原文链接：https://blog.csdn.net/u013113678/article/details/113765937
c语言 hashmap
12-03
在C语言中实现哈希表，可以帮助我们快速地存储和查找数据，尤其是在需要高效查找性能的应用场景下。本节将详细介绍如何用C语言创建一个跨平台的哈希表，支持Windows和Linux操作系统。 首先，我们需要理解哈希表的...
散列的C语言实现知识汇总
08-10
3. **C语言实现**：在C语言中，通常使用结构体来表示散列表。例如，定义一个包含键值对（Pair）、状态（State，用于标识项是否被使用或删除）的结构体`HashEntry_t`，再定义一个包含数组`map`（存储`HashEntry_t`）...
c语言实现LRU缓存.zip
02-27
总的来说，C语言实现LRU缓存是一项挑战性的任务，它要求开发者具备扎实的编程基础，对数据结构和算法有深入的认识。通过理解和实践这个项目，可以提升在内存管理、数据结构和算法设计等方面的能力。
c语言map的用法总结
qq_63108111的博客
04-06 7447
map是STL的一个关联容器，它提供一对一的hash。第一个可以称为关键字(key)，每个关键字只能在map中出现一次；第二个可能称为该关键字的值(value)所有元素会根据键值来自动排序。
C语言实现Hash Map(1)：Map基础知识入门
主要分享硬件、嵌入式软件部分知识
05-21 2386
Map是一种关联容器，它存储键值对（），通过键（key）来快速查找对应的值（value插入（Insert）：将一个键值对插入Map。查找（Find）：根据键查找对应的值。删除（Delete）：从Map中删除一个键值对。在本篇博客中，介绍了Map的基本概念和两种主要实现方式：Hash Map和红黑树Map。我们还简要介绍了C++标准库中的std::map和。在下一篇博客中，我将深入探讨如何在C语言中实现一个简单的Hash Map。
c语言实现hash map（链表散列hash）
weixin_39936714的博客
06-15 4721
散列(hash)： 将字符串转换为固定长度的数组或索引值的方法，叫做散列法。 hashmap的底层结构 hashmap是一个链表散列的数据结构，即是数组和链表的结合体。（也可能是数组+链表+红黑树） 数组：存储空间连续，占用内存严重，寻址容易，插入删除数据困难 链表：存储数据离散，内存不连续，寻址困难，插入删除数据容易 hashmap综合了数组和链表的优点，实现了寻址容易，插入删除数据同样容易 h...
C语言hashmap实现
lengyue2015的博客
09-16 2099
C语言hashmap实现，不做线程控制 map.h #ifndef _MAP_H #define _MAP_H /** * * 文件说明： * 纯C实现hashmap，由于限制，map中的key采用char*，如果key为其他类型的请先转换成char* * 文件创建时间： * 2020-09-16 13:58 * hashmap实现原理描述： * hashmap实现采用数组加链表，首先将key生成一个int类型的hashcode值，然后根据hashcode值进
C语言-手写Map(数组+链表+红黑树)(全功能)
weixin_45203607的博客
09-01 1655
C语言-手写Map(数组+链表+红黑树)(全功能)
c语言map的实现-使用内核红黑树
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
C语言hashmap
juy19901128的专栏
11-29 1450
前几天在用stl中hash_map的时候，发现char*做为key，在比较的时候是直接==，这很蛋疼，我字符串比较你就给直接==，逗我呢。 但是可以重定义hash和compare函数来达到效果，想了想，弄一个这么难用的hash_map还要自己实现，那我还不如自己写一个得了，于是就有了下面的代码。 通过地址散列和链表冲突来实现。 头文件： #ifndef _E_MAP_H_
C语言实现Hash Map(2)：Map代码实现详解
最新发布
主要分享硬件、嵌入式软件部分知识
05-22 2160
基于本篇文章，我们已经学习到了哈希map实现的基本逻辑。另外，前面我们有提到，这个代码在值声明为其它几个数据类型的情况下，根本运行不了，或者并不方便我们开发程序(有时我们希望直接传值而不是变量地址)，然后还有内存分配和初始化桶数量的地方可以优化。那么下一篇文章，我们就来解决这些问题，并优化这个代码。
算法与数据结构之二叉树1（待补充）
m0_66076989的博客
10-30 230
用递归和非递归两种方式实现二叉树的先序、中序、后序遍历；如何直观的打印一颗二叉树；如何完成二叉树的宽度优先遍历(常见题目:求一棵二叉树的宽度)
c语言实现hashmap
05-30
实现哈希表（Hashmap）的基本思路是将键值对存储在一个数组中，通过哈希函数将键转换为数组的索引，然后将值存储在该索引处。 下面是一个简单的C语言实现哈希表的例子： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define TABLE_SIZE 100 typedef struct { char* key; int value; } hash_node; hash_node* hash_table[TABLE_SIZE]; int hash_function(char* key) { int hash = 0; for (int i = 0; i < strlen(key); i++) { hash += key[i]; } return hash % TABLE_SIZE; } void insert(char* key, int value) { int index = hash_function(key); if (hash_table[index] == NULL) { hash_table[index] = malloc(sizeof(hash_node)); hash_table[index]->key = strdup(key); hash_table[index]->value = value; } else { hash_node* node = hash_table[index]; while (node->next != NULL) { node = node->next; } node->next = malloc(sizeof(hash_node)); node->next->key = strdup(key); node->next->value = value; } } int search(char* key) { int index = hash_function(key); hash_node* node = hash_table[index]; while (node != NULL) { if (strcmp(node->key, key) == 0) { return node->value; } node = node->next; } return -1; } int main() { insert("apple", 1); insert("banana", 2); insert("orange", 3); printf("apple = %d\n", search("apple")); printf("banana = %d\n", search("banana")); printf("orange = %d\n", search("orange")); return 0; } ``` 这个例子中，我们使用一个简单的哈希函数，将字符串中所有字符的ASCII码之和作为哈希值。我们将哈希表的大小设为100，即数组的长度为100。如果两个不同的键具有相同的哈希值，我们采用链表的方式来处理冲突。 在主函数中，我们插入了三个键值对，然后通过搜索函数查找对应的值。运行程序，可以得到以下输出： ``` apple = 1 banana = 2 orange = 3 ``` 这表明我们的哈希表实现是正确的。当然，这只是一个简单的实现，实际应用中需要考虑更多的因素，例如哈希函数的设计、冲突处理的效率等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小锋学长生活大爆炸

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

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

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

打赏作者

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

抵扣说明：

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

余额充值