C语言hashmap

最新推荐文章于 2025-02-13 18:27:00 发布
最新推荐文章于 2025-02-13 18:27:00 发布
阅读量1.4k 收藏
点赞数
分类专栏： C语言 文章标签： C语言 hashmap map hash stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/juy19901128/article/details/78664053
版权

前几天在用stl中hash_map的时候，发现char*做为key，在比较的时候是直接==，这很蛋疼，我字符串比较你就给直接==，逗我呢。

但是可以重定义hash和compare函数来达到效果，想了想，弄一个这么难用的hash_map还要自己实现，那我还不如自己写一个得了，于是就有了下面的代码。

通过地址散列和链表冲突来实现。

头文件：

#ifndef _E_MAP_H_
#define _E_MAP_H_
#include "common.h"

#ifdef __cplusplus  
extern "C" {  
#endif 

// 在调用了if_map_delete\if_map_clear之后，这个回调来处理value
// 如果是safe状态，那么回调结束后会回收，不是safe状态,key将由你来释放内存
// value的必须要你来释放内存
typedef void (if_map_valueDeleteCallBack)(void *key, void* value);

// 初始化一个map
// capacity: -1表示自动扩容，0表示没有大小，put/get任何都会失败
// safe: FALSE 表示map不会为key生成一份copy，这样key有可能会被你修改，则会出错;
//       TRUE 则会为key生成一份copy，这样会导致内存稍微增大，但是key不会被修改
// key在移除的时候会始终删除
void* if_map_new(int capacity, BOOL safe, if_map_valueDeleteCallBack *vdcb);

// 放入一个key value
// return: 如果之前存在这个key，那么之前的值会返回
void* if_map_put(void* map, char* key, void* value);
// 得到value
void* if_map_get(void* map, char* key);
// map的value数量
int if_map_size(void* map);

// 得到所有values
// 配合size使用
void** if_map_values(void* map);
// 是否存在
BOOL if_map_has(void* map, char* key);
// 是否包含这个value值，简单的value == value
BOOL if_map_contain(void* map, void* value);
// 通过key，移出key-value
void* if_map_remove(void* map, char* key);
// 通过value，移出key-value
void* if_map_removeValue(void* map, void* value);
// 移出所有key-value
void if_map_clear(void* map);

// 释放map内存
void if_map_delete(void* map);

#ifdef __cplusplus  
}  
#endif 

#endif


C文件 

#include "map.h"
#include "util.h"

// key采用取留余数法
// 解决冲突采用链地址法

typedef struct if_pair_struct {
	char *key;
	void *value;
} ifpair;


typedef struct if_node_struct {
	ifpair *pair;
    struct if_node_struct *next;
} ifnode;

typedef struct if_map_struct {
    BOOL safe;
    int capacity;
    int size;
    BOOL autoExpand;
    if_map_valueDeleteCallBack *valueCallback;
    // node集合
    ifnode **nodes;
} ifmap;

#define MAP_DEFAULT_SIZE 16
#define EXPAND_THRESHOLD_RATE 0.75
#define EXPAND_FACTOR 2

// hash算法
// put性能
static int hash(int capacity, char* key) {
    int h = 1;
    char ch;
    while (ch = *key++) {
        h = 31 * h + ch;
    }

    return abs(h % capacity);
}

// key的比较函数
// get性能
static BOOL compare(char *k1, char *k2) {
	return if_str_cmp(k1, k2) == 0;
}

// 对map进行扩容
static void expand(ifmap *map) {
    int i;

    register int preCapacity = map->capacity;
    // 保存之前的node数组
    register ifnode **preNodes = map->nodes;

    // 扩容
    map->capacity = map->capacity * EXPAND_FACTOR;
    map->nodes = (ifnode**) malloc (sizeof(ifnode*) * map->capacity);
    memset(map->nodes, 0, sizeof(ifnode*) * map->capacity);

    // 移动node
    for (i = 0; i < preCapacity; i++) {
        ifnode *node = preNodes[i];
        if (node) {
            int hsKey = hash(map->capacity, node->pair->key);
            map->nodes[hsKey] = node;
        }
    }

	free(preNodes);
}


// 删除pair，只会删除key，不会删除value
static void if_map_deletePair(ifpair *pair, BOOL safe, if_map_valueDeleteCallBack *cb) {
    if (pair) {
        // 只需要释放key
		if (cb) {
            cb(pair->key, pair->value);
        }
		if (pair->key && safe) {
			free(pair->key);
			pair->key = 0;
		}
        free(pair);
    }
}

// 删除pair，只会删除key，不会删除value
static void if_map_deleteNode(ifnode *node, BOOL deletePair, BOOL safe, if_map_valueDeleteCallBack *cb) {
    if (node) {
        // 只需要释放key
        if (deletePair && node->pair) {
            if_map_deletePair(node->pair, safe, cb);
        }
        free(node);
    }
}

// 在一个map中放入一个node
// check: 是否检查是否重复的key值
// 检查存在 返回之前的pair
static ifpair* if_map_putPair(ifmap *map, ifpair *pair, BOOL check) {
    int hsKey = hash(map->capacity, pair->key);
    ifnode *hashNode = map->nodes[hsKey];
    ifnode **ptr = NULL;

    if (hashNode) {
        // 存在node
        // 检查元素的key值
        if (check) {
            if (compare(pair->key, hashNode->pair->key)) {
                // 这个存在，那么替换pair
                ifpair *tmpPair = hashNode->pair;
                hashNode->pair = pair;

                return tmpPair;
            }
        }

        // 之前的位置上有node，那么需要循环链式遍历
        while (hashNode->next) {
            hashNode = hashNode->next;
        }
        ptr = &(hashNode->next);
    } else {

        // 不存在node
        ptr = &(map->nodes[hsKey]);
    }

    {
        // 构造一个新的node
        ifnode *node = (ifnode*) malloc (sizeof(ifnode));
        
		// 内存分配失败
		if (!node) {
			return NULL;
		}
		
		node->pair = pair;
        node->next = NULL;
		
        *ptr = node;

        // 大小+1
        map->size++;
    }

    return NULL;
}

// remove: 是否在得到的时候移出
static ifpair* if_map_getPair(ifmap* map, char* key, BOOL remove) {
    int hs = hash(map->capacity, key);
    ifnode *topNode = map->nodes[hs];
    ifnode *node = topNode;
    ifnode *preNode = NULL;
    ifpair *pair = NULL;

    while (node) {
        if (compare(key, node->pair->key)) {
            // 找到
            pair = node->pair;
            break;
        } else {
            // 没有找到
            preNode = node;
            node = node->next;
        }
    }

    if (pair && remove) {
        if (node == topNode) {
            // 位于散列表
            map->nodes[hs] = topNode->next;
        } else {
            // 位于链表
            preNode->next = node->next;
			if_map_deleteNode(node, FALSE, map->safe, NULL);
        }

        map->size--;
    }

    return pair;
}

// remove: 是否在得到的时候移出
static ifpair* if_map_getPairValue(ifmap* map, void* value, BOOL remove) {
    int i;
	ifpair *pair = NULL;

    for (i = 0; i < map->capacity; i++) {
        ifnode *topNode = map->nodes[i];
        ifnode *node = topNode;
        ifnode *preNode = NULL;

        while (node) {
            if (value == node->pair->value) {
                pair = node->pair;
                break;
            } else {
                // 没有找到
                preNode = node;
                node = node->next;
            }
        }

        if (pair && remove) {
            if (node == topNode) {
                // 位于散列表
                map->nodes[i] = topNode->next;
            } else {
                // 位于链表
                preNode->next = node->next;
				if_map_deleteNode(node, FALSE, map->safe, NULL);
            }

            map->size--;
        }

		if (pair) {
			break;
		}

    }

    return pair;
}

// 初始化一个map
// size: -1表示自动扩容，0表示没有大小，put/get任何都会失败
// safe: FALSE 表示map不会为key生成一份copy，这样key有可能会被你修改，则会出错; TRUE 则会为key生成一份copy，这样会导致内存稍微增大，但是key不会被修改
void* if_map_new(int capacity, BOOL safe, if_map_valueDeleteCallBack *vdcb) {
    ifmap *map = (ifmap*) malloc (sizeof(ifmap));
	memset(map, 0, sizeof(ifmap));

    if (capacity < 0) {
        // 自动扩容
        map->autoExpand = TRUE;
        map->size = 0;
        map->capacity = MAP_DEFAULT_SIZE;
    } else {
        map->autoExpand = FALSE;
        map->size = 0;
        map->capacity = capacity;
    }
	map->valueCallback = vdcb;
    map->safe = safe;
    // 分配节点指针空间
    map->nodes = (ifnode**) malloc (sizeof(ifnode*) * map->capacity);
    memset(map->nodes, 0, sizeof(ifnode*) * map->capacity);

	return map;
}

// 放入一个key value
// return: 如果之前存在这个key，那么之前的值会返回
void* if_map_put(void* m, char* key, void* value) {
    ifmap *map = (ifmap*) m;

    if (if_str_len(key) == 0) {
        return NULL;
    }

    // 判断是否超过限制
    if (!map->autoExpand && map->size >= map->capacity) {
        return NULL;
    }

    // 判断是否需要扩容
    if (map->autoExpand && map->size >= (map->capacity * EXPAND_THRESHOLD_RATE)) {
        // 开始扩容
        expand(map);
    }

    {
        // 构造一个pair
        void *ret = NULL;
        ifpair *pair = (ifpair*) malloc (sizeof(ifpair));

        // 为了安全
        if (map->safe) {
            key = if_str_clone(key);
        }

        pair->key = key;
        pair->value = value;
        pair = if_map_putPair(map, pair, TRUE);

        // 之前存在相同的key的pair
        if (pair) {
            ret = pair->value;
            if_map_deletePair(pair, map->safe, NULL);
        }

        return ret;
    }
}

// 得到value
void* if_map_get(void* m, char* key) {
    if (if_str_len(key) == 0 || !m) {
        return NULL;
    } else {
        ifmap *map = (ifmap*) m;
        void *ret = NULL;
        ifpair *pair = if_map_getPair(map, key, FALSE);
        if (pair) {
            ret = pair->value;
        }

        return ret;
    }
}
// map的value数量
int if_map_size(void* m) {
    if (!m) {
        return -1;
    } else {
        ifmap *map = (ifmap*)m;
        return map->size;
    }
}


// 得到所有values
// 使用完请释放内存
void** if_map_values(void* m) {
    if (!m) {
        return NULL;
    } else {
        int i;
        ifmap *map = (ifmap*)m;
        void **ret = (void**) malloc (sizeof(void*) * map->size);
		int valuePtr = 0;
        for (i = 0; i < map->capacity; i++) {
            ifnode *node = map->nodes[i];

            while (node) {
                ret[valuePtr++] = node->pair->value;
                node = node->next;
            }
        }

        return ret;
    }
}
// 是否存在
BOOL if_map_has(void* m, char* key) {
    if (!m) {
        return FALSE;
    } else {
        int i;
        ifmap *map = (ifmap*)m;
		ifnode *node = map->nodes[hash(map->capacity, key)];
        while (node) {
            if (compare(key, node->pair->key)) {
                return TRUE;
            }
            node = node->next;
        }

        return FALSE;
    }
}
// 是否包含这个value值，简单的value == value
BOOL if_map_contain(void* m, void* value) {
    if (!m) {
        return FALSE;
    } else {
        int i;
        ifmap *map = (ifmap*)m;
        for (i = 0; i < map->capacity; i++) {
            ifnode *node = map->nodes[i];

            while (node) {
                if (value == node->pair->value) {
                    return TRUE;
                }
                node = node->next;
            }
        }

        return FALSE;
    }
}
// 通过key，移出key-value
void* if_map_remove(void* m, char* key) {
    if (if_str_len(key) == 0 || !m) {
        return NULL;
    } else {
        ifmap *map = (ifmap*) m;
        void *ret = NULL;
        ifpair *pair = if_map_getPair(map, key, TRUE);
        if (pair) {
            ret = pair->value;
            if_map_deletePair(pair, map->safe, NULL);
        }

        return ret;
    }
}
// 通过value，移出key-value
// 通过遍历查找，没有用value来索引
void* if_map_removeValue(void* m, void* value) {
    if (!m) {
        return NULL;
    } else {
        ifmap *map = (ifmap*) m;
        void *ret = NULL;
        ifpair *pair = if_map_getPairValue(map, value, TRUE);
		if (pair) {
			ret = pair->value;
		}
        return ret;
    }
}

// 移出所有
void if_map_clear(void* m) {
    if (!m) {
        return;
    } else {
		int i;
        ifmap *map = (ifmap*) m;
		// 遍历node
        for (i = 0; i < map->capacity; i++) {
            ifnode *node = map->nodes[i];
            while (node) {
				ifnode *nextNode = node->next;
                if_map_deleteNode(node, TRUE, map->safe, map->valueCallback);
				node = nextNode;
            }
        }
		memset(map->nodes, 0, sizeof(ifnode*) * map->capacity);
		map->size = 0;
        return;
    }
}


// 释放一个map的内存
void if_map_delete(void* m) {
    if (!m) {
        return;
    } else {
		int i;
        ifmap *map = (ifmap*) m;

        // 遍历node
        for (i = 0; i < map->capacity; i++) {
            ifnode *node = map->nodes[i];

            while (node) {
                ifnode *nextNode = node->next;
                if_map_deleteNode(node, TRUE, map->safe, map->valueCallback);
				node = nextNode;
            }
        }

        free(map->nodes);
        free(map);
    }
}


完整代码地址： https://gitee.com/lastcoder/ifserver 文件夹ifclient


用C语言实现哈希表HashMap
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
01-14 2349
用C语言，基于动态数组+链表的形式实现的的HashMap
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.youkuaiyun.com/sxf1061700625/article/details/109594495
c语言 hashmap
12-03
纯c语言的hashmap，支持windows，linux，
map函数详解
最新发布
2301_81394465的博客
02-13 2722
map是一种映射，是常用的STL容器。（map可以将任何基本类型（包括STL容器）映射到任何基本类型（包括STL容器））使用map要确定映射前类型（键key）和映射后的类型（值value）。map统计数据（如单词频率、计数等）。存储键值对并保持键唯一。在需要排序的情况下存储数据。实现缓存、查找表（如记忆化搜索）。频繁进行查找、更新操作。区间查找和范围查询。由于map提供了高效的查找、插入和删除操作，适用于各种需要快速存取、排序和更新的数据处理任务。
C语言的hashmap
mrbone9的博客
03-28 4271
在算法练习当中，常常会遇到用 hashmap 来实现的思路，通过 key-value 方便快捷的查找，增加，删除特定数据。 在高级语言当中，c++或java都有一套 hashmap API可供使用，但是 C 语言却没有系统的 不过开源项目为我们提供了这套工具，利用这套工具，可以方便的将自定义数据结构 hash 话 官网文档： uthashhttps://troydhanson.github.io/uthash/userguide.html#_a_hash_in_c git 仓库 uthash
c语言hashmap
09-27
哈希表，或称为HashMap，在C语言中通常不是内置的数据结构，而是通过自定义数据结构和函数实现的。哈希表是一种高效的数据存储和查找方式，它基于键值对，利用哈希函数将键映射到一个固定的位置，使得插入、删除和...
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实现
lengyue2015的博客
09-16 2186
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语言版本的HashMap实现
qq_39760347的博客
07-20 1138
c语言实现hashmap
c语言实现哈希字典Hashmap
10-14
做项目写业务逻辑的时候经常用到的数据结构有2个，一个是动态数组还一个是字典。大部分编程语言，都有提供上述两种数据结构的集合类标准库。但是c语言是没有提供这类标准库的，本资源提供的是一个可以在正式项目中使用的纯c语言实现的哈希字典。原文链接：https://blog.youkuaiyun.com/u013113678/article/details/113765937
源码解析系列：HashMap(5) - c语言实现一个HashMap
Jwasx的博客
01-14 1405
文章目录1. 前言2. 开始C语言之旅 1. 前言 HashMap(5)中主要介绍了我的一个数据结构实验课设，而这个课设是实现一个HashMap，政整个HashMap的实现是以java JDK1.8的HashMap为参考实现的，其实说是参考，大部分其中的方法是和java源码一样的，在红黑树的方面则是自己设计的。对于这个课设，也有一些和HashMap不一样的地方，比如Key和Value都是使用int类型的，数组下标不再存放无头单链表，而是存放有头单链表，这其实都是其中一些坑，后来慢慢改成这样的。对于Ha..
C HashMap
weixin_33728268的博客
12-26 471
一个简单的HashMap C语言实现 blog.youkuaiyun.com/cheungmine/article/details/1894219   http://ubuntuforums.org/showthread.php?t=1222055 http://elliottback.com/wp/hashmap-implementation-in-c/ http://stackoverflo...
hashmap的c语言实现原理,HashMap归纳（一）
weixin_42540248的博客
05-22 408
前段时间，自己面试以及面试别人，都多次涉及到HashMap的原理，其实我自己也有点迷糊，不像刚学习的时候清晰，借写这篇博客的机会，回顾巩固一下第一篇先来看下HashMap的定义和基本用法一、HashMap的定义根据百度百科，HashMap是基于基于哈希表的Map。我们先搞清楚Map的定义，列下JAVA中的注释：An object that maps keys to values. A map c...
使用C语言实现一个简单的哈希表HashMap
jackiendsc的博客
12-05 439
HashMap是一种常用的哈希表实现，它将键（key）映射到值（value）上。它使用哈希函数将键映射到哈希表中的索引，以便快速查找键值对。HashMap的实现基于数组和链表或红黑树，它通过散列函数来确定每个键值对在数组中的位置。
C语言实现Hash Map(1)：Map基础知识入门
主要分享硬件、嵌入式软件部分知识
05-21 2880
Map是一种关联容器，它存储键值对（），通过键（key）来快速查找对应的值（value插入（Insert）：将一个键值对插入Map。查找（Find）：根据键查找对应的值。删除（Delete）：从Map中删除一个键值对。在本篇博客中，介绍了Map的基本概念和两种主要实现方式：Hash Map和红黑树Map。我们还简要介绍了C++标准库中的std::map和。在下一篇博客中，我将深入探讨如何在C语言中实现一个简单的Hash Map。
hashmap c
weixin_30505043的博客
10-20 111
问题提出： 假如一个结构体，记录有学号，姓名。现在内存块中存在着一批此类结构体。如果已知一个学号，要从这些结构体中找出对应的姓名。 问题解决方法： 如果使用链表保存这些结构体，就要遍历这个链表中的结构体，比较每个结构体的学号成员，如果相等就返回这个结构体，从而得到结构体的姓名成员。 但是遍历效率太低，浪费cpu，有点费电。不如使用hash表直接定位到对应的结构体，而不必遍历。 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值