map容器的c实现

最新推荐文章于 2024-05-21 07:00:00 发布
最新推荐文章于 2024-05-21 07:00:00 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： C++ 上机


原文来自：http://blog.chinaunix.net/uid-21457204-id-3063180.html

主要是使用红黑树这种数据结构封装一个MAP容器，本来想模仿STL MAP，不过现在暂时实现，今后会改进，目前还没实现加锁这功能，不过可以支持win32和linux平台。。。

以下是源代码:

  1. /*
  2. * file: main.c
  3. * author: vincent.cws2008@gmail.com
  4. * history:
  5. * initial @ 2012-01-31
  6. */

  8. #define DEBUG

  10. #include <stdio.h>
  11. #include <time.h>
  12. #include <stdlib.h>
  13. #include <string.h>

  15. #include "map.h"

  17. #ifdef DEBUG
  18. #define dump(a,s) __dump((a),(s))
  19. #else
  20. #define dump(a,s)
  21. #endif


  24. typedef struct word_info {
  25. unsigned long hash_major;
  26. unsigned long hash_minor;
  27. char *path;
  28. unsigned long line;
  29. unsigned long col;
  30. }word_info_t;

  32. typedef struct priv_info {
  33. unsigned long key;
  34. char val[10];
  35. }priv_info_t;


  38. static void __dump(priv_info_t *array, size_t num)
  39. {
  40. int i;
  41. printf("-- DUMP START -- \n");
  42. for (i=0; i < num; i++)
  43. {
  44. printf("array[%d].key=%03d, array[%d].val=%s\n",
  45. i, array[i].key, i, array[i].val);
  46. }
  47. printf("-- DUMP END -- \n");
  48. }

  50. #define map_info(pm) {\
  51. printf("-- dump map start ... --\n"); \
  52. map_dump(pm); \
  53. printf("-- dump map end ... --\n"); \
  54. }

  56. #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))

  58. #define MAX_NUM 20

  60. int main()
  61. {
  62. map_t map1;
  63. int key;
  64. int i, j;
  65. priv_info_t priv_info[MAX_NUM];

  67. srand(time(0));

  69. memset(priv_info, 0, sizeof(priv_info));
  70. for (i=0; i<MAX_NUM; i++)
  71. {
  72. key = rand()%MAX_NUM;
  73. priv_info[i].key = key;
  74. sprintf(priv_info[i].val, "i am %d", key);
  75. }
  76. dump(priv_info, ARRAY_SIZE(priv_info));

  78. map_init(&map1);

  80. i = 0;
  81. while (i < MAX_NUM)
  82. {
  83. struct mnode* node;
  84. printf("-- %d -- \n", i);
  85. node = map_find(&map1,&(priv_info[i].key), NULL);
  86. if (!node) {
  87. printf("->>> insert node: priv_info[%d].key=%d \n", i, priv_info[i].key);
  88. map_insert_alloc(&map1, &(priv_info[i].key),
  89. &priv_info[i], sizeof(priv_info[i]), NULL);
  90. } else {
  91. /* key not matched, so just print out */
  92. printf("priv_info[%d].key=%d is exist!\n", i, priv_info[i].key);
  93. for (j=0; j < MAX_NUM; j++) {
  94. if(priv_info[j].key == priv_info[i].key && i!=j)
  95. printf("\t|-- priv_info[%d].key=%d\n", j, priv_info[j].key);
  96. }
  97. }
  98. map_info(&map1);

  100. i++;
  101. }
  102. map_info(&map1);

  104. printf("-----------------------------------\n");
  105. for (i=0; i < MAX_NUM; i++)
  106. {
  107. struct mnode* node;
  108. node = map_find(&map1,&i, NULL);
  109. if (node){
  110. map_remove_free(&map1, &i, NULL);
  111. printf("--> key=%03d deleted!\n", i);
  112. map_info(&map1);
  113. }else{
  114. printf("key=%03d not found!\n", i);
  115. }
  116. }
  117. map_info(&map1);

  119. map_exit(&map1);
  120. return 0;
  121. }

.............................................................................................
.............................................................................................


  1. /*
  2. * file: map.h
  3. * author: vincent.cws2008@gmail.com
  4. * history:
  5. * initial @ 2012-01-31
  6. */
  7. #ifndef __MAP_H__
  8. #define __MAP_H__

  10. #include <stdlib.h>
  11. #include "platform.h"
  12. #include "rbtree.h"

  14. #define lock_t int
  15. #define lock_init(x)
  16. #define lock_exit(x)

  18. #ifndef NULL
  19. #define NULL 0
  20. #endif

  22. #define __assert(x)
  23. #define __free(x) free(x)
  24. #define __malloc(x) malloc(x)
  25. #define __memcpy(d,s,len) memcpy((d),(s),(len))

  27. extern struct map;

  29. typedef int (*CMP_FUNC)(const void *d1, const void *d2);

  31. typedef struct mnode{
  32. struct rb_node node;
  33. void *key;
  34. void *private;
  35. }mnode_t;

  37. /*
  38. typedef struct ops{
  39. struct mnode*(*find)(struct map *map, void *key, CMP_FUNC cmpf);
  40. int (*insert_alloc)(struct map *map, void *key,
  41. void *private, size_t size, CMP_FUNC cmpf);
  42. int (*remove_free)(struct map *map, void *key, CMP_FUNC cmpf);
  43. int (*insert)(struct map *map, struct mnode *data, CMP_FUNC cmpf);
  44. int (*remove)(struct map *map, void *key, CMP_FUNC cmpf);
  45. }ops_t;
  46. */

  48. typedef struct map{
  49. struct rb_root root;
  50. lock_t lock;
  51. }map_t;

  53. extern int map_init(struct map* map);
  54. extern int map_exit(struct map* map);

  56. struct mnode* __rbfind(struct map *map, void *key, CMP_FUNC cmpf);
  57. int __rbinsert_alloc(struct map *map, void *key,
  58. void *private, size_t size, CMP_FUNC cmpf);
  59. int __rbremove_free(struct map *map, void *key, CMP_FUNC cmpf);
  60. int __rbinsert(struct map *map, struct mnode *data, CMP_FUNC cmpf);
  61. int __rbremove(struct map *map, void *key, CMP_FUNC cmpf);

  63. #define map_find(map,key,cmpf) \
  64. __rbfind((map),(key),(cmpf))

  66. #define map_insert_alloc(map,key,priv,size,cmpf) \
  67. __rbinsert_alloc((map),(key),(priv),(size),(cmpf))

  69. #define map_remove_free(map,key,cmpf) \
  70. __rbremove_free((map),(key),(cmpf))

  72. #if 0
  73. #define map_insert(map,data,cmpf) \
  74. __rbinsert((map),(data),(cmpf))
  75. #define map_remove(map,key,cmpf) \
  76. __rbremove((map),(key),(cmpf))
  77. #endif


  80. #define map_entry(ptr, type, member) container_of(ptr, type, member)

  82. extern struct mnode *map_first(const struct map *map);
  83. extern struct mnode *map_last(const struct map *map);
  84. extern struct mnode *map_next(const struct mnode *mnode);
  85. extern struct mnode *map_prev(const struct mnode *mnode);

  87. extern void map_dump(const struct map* map);


  90. #endif
.............................................................................................
.............................................................................................

  1. /*
  2. * file: map.c
  3. * author: vincent.cws2008@gmail.com
  4. * history:
  5. * initial @ 2012-01-31
  6. */
  7. #define DEBUG
  8. #include "map.h"

  10. #define mnode_init(mnode) {\
  11. (mnode)->node.rb_parent_color=0; \
  12. (mnode)->node.rb_right=0; \
  13. (mnode)->node.rb_left=0; \
  14. (mnode)->key=0; \
  15. (mnode)->private=0; \
  16. }


  19. void map_dump(const struct map* map)
  20. {
  21. struct mnode *mnode;
  22. int cnt=0;
  23. for (mnode = map_first(map); mnode; mnode = map_next(mnode))
  24. printf("key=%03d%s", *(int*)mnode->key, ++cnt%10==0?"\n":" ");
  25. printf("\n");
  26. }


  29. static int __cmp_default(long *d1, long *d2)
  30. {
  31. // printf("-- d1:%d, d2:%d\n", *d1, *d2);
  32. if (*d1 < *d2) return -1;
  33. else if (*d1 > *d2) return 1;
  34. else return 0;
  35. }

  37. struct mnode* __rbfind(struct map *map, void *key, CMP_FUNC cmpf)
  38. {
  39. int result;
  40. CMP_FUNC cmp;
  41. struct mnode *data;
  42. struct rb_node *node = map->root.rb_node;

  44. __assert(map && key);

  46. cmp = cmpf ? cmpf : __cmp_default;
  47. /* printf("==> entry %s key:%d\n", __func__, *(int*)key); */
  48. while (node)
  49. {
  50. data = container_of(node, struct mnode, node);
  51. /* printf("data->key:%d VS key:%d\n", *(int*)(data->key), *(int*)key);*/
  52. result = cmp(key, data->key);
  53. /*printf("result=%d, node->rb_left=%p, node->rb_right=%p\n",
  54. result, node->rb_left, node->rb_right);*/
  55. if (result < 0)
  56. node = node->rb_left;
  57. else if (result > 0)
  58. node = node->rb_right;
  59. else
  60. return data;
  61. }
  62. //printf("node=%p\n", node);
  63. return NULL;
  64. }

  66. int __rbinsert(struct map *map, struct mnode *data, CMP_FUNC cmpf)
  67. {
  68. int result;
  69. struct mnode *this;
  70. CMP_FUNC cmp;
  71. struct rb_node **new = &(map->root.rb_node), *parent = NULL;

  73. __assert(map && data);

  75. cmp = cmpf ? cmpf : __cmp_default;

  77. /* Figure out where to put new node */
  78. while (*new)
  79. {
  80. this = container_of(*new, struct mnode, node);
  81. result = cmp(data->key, this->key);

  83. parent = *new;
  84. if (result < 0) new = &((*new)->rb_left);
  85. else if (result > 0) new = &((*new)->rb_right);
  86. else return -2;
  87. }
  88. /* Add new node and rebalance tree. */
  89. rb_link_node(&(data->node), parent, new);
  90. rb_insert_color(&(data->node), &(map->root));
  91. return 0;
  92. }

  94. int __rbremove(struct map *map, void *key, CMP_FUNC cmpf)
  95. {
  96. struct mnode* data = __rbfind(map, key, cmpf);
  97. __assert(map && key);
  98. if (data)
  99. rb_erase(&(data->node), &(map->root));
  100. return 0;
  101. }

  103. int __rbinsert_alloc(struct map *map, void *key,
  104. void *private, size_t size, CMP_FUNC cmpf)
  105. {
  106. struct mnode *new;
  107. __assert(map && key && private);
  108. new = (struct mnode*)__malloc(size+sizeof(struct mnode));
  109. __assert(new);
  110. mnode_init(new);
  111. new->key = key;
  112. new->private = new+1;
  113. if (private)
  114. __memcpy(new->private, private, size);

  116. return __rbinsert(map, new, cmpf);
  117. }

  119. int __rbremove_free(struct map *map, void *key, CMP_FUNC cmpf)
  120. {
  121. struct mnode* data;
  122. __assert(map && key);
  123. data = __rbfind(map, key, cmpf);
  124. /* printf("%s: key: %d\n", __func__, *(int*)(data->key)); */
  125. if (data)
  126. {
  127. /* printf("%s: deleted!\n", __func__);*/
  128. rb_erase(&(data->node), &(map->root));
  129. __free(data);
  130. }
  131. return 0;
  132. }

  134. struct mnode *map_first(const struct map *map)
  135. {
  136. struct rb_node *node;
  137. __assert(map);
  138. node = rb_first(&(map->root));
  139. if(node)
  140. return map_entry(node, struct mnode, node);
  141. return NULL;
  142. }

  144. struct mnode *map_last(const struct map *map)
  145. {
  146. struct rb_node *node;
  147. __assert(map);
  148. node = rb_last(&(map->root));
  149. if(node)
  150. return map_entry(node, struct mnode, node);
  151. return NULL;
  152. }

  154. struct mnode *map_next(const struct mnode *mnode)
  155. {
  156. struct rb_node *node;
  157. __assert(mnode);
  158. node = rb_next(&(mnode->node));
  159. if(node)
  160. return map_entry(node, struct mnode, node);
  161. return NULL;
  162. }

  164. struct mnode *map_prev(const struct mnode *mnode)
  165. {
  166. struct rb_node *node;
  167. __assert(mnode);
  168. node = rb_prev(&(mnode->node));
  169. if(node)
  170. return map_entry(node, struct mnode, node);
  171. return NULL;
  172. }


  175. int map_init(struct map* map)
  176. {
  177. map->root.rb_node = NULL;
  178. lock_init(map->lock);
  179. return 0;
  180. }

  182. int map_exit(struct map* map)
  183. {
  184. lock_exit(map->lock);
  185. return 0;
  186. }
Tonyswift
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript实现Java中Map容器的方法
11-23
本文实例讲述了JavaScript实现Java中Map容器的方法。分享给大家供大家参考，具体如下： 声明一下,JavaScript和Java的区别就像雷锋和雷峰塔的区别. 在Java中,Map是一种集合,用来存储Key-Value键值对的容器.根据键得到...
通用红黑树（Tree-Map）容器纯C实现
08-05
纯C实现的通用红黑树容器不好找，于是自己琢磨着实现了一个。 算法部分直接剪裁自Linux内核中的rbtree 作者主要是在此基础上封装了一个通用的容器 里面含有 test例子 以及 benchmark基准测试 另外这个是Windows和...
c语言map的用法总结
qq_63108111的博客
04-06 6486
map是STL的一个关联容器，它提供一对一的hash。第一个可以称为关键字(key)，每个关键字只能在map中出现一次；第二个可能称为该关键字的值(value)所有元素会根据键值来自动排序。
C语言-手写Map(数组+链表+红黑树)(全功能)
weixin_45203607的博客
09-01 1597
C语言-手写Map(数组+链表+红黑树)(全功能)
C语言实现Hash Map(1)：Map基础知识入门
最新发布
主要分享硬件、嵌入式软件部分知识
05-21 1717
Map是一种关联容器，它存储键值对（），通过键（key）来快速查找对应的值（value插入（Insert）：将一个键值对插入Map。查找（Find）：根据键查找对应的值。删除（Delete）：从Map中删除一个键值对。在本篇博客中，介绍了Map的基本概念和两种主要实现方式：Hash Map和红黑树Map。我们还简要介绍了C++标准库中的std::map和。在下一篇博客中，我将深入探讨如何在C语言中实现一个简单的Hash Map。
c语言map的实现-使用内核红黑树
热门推荐
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
【算法】【基础数据类型】C语言版本的HashMap实现
qq_39760347的博客
07-20 827
c语言实现hashmap
C 语言版的stl简单实现
12-26
1. 容器（Containers）：如vector（动态数组）、list（双向链表）、deque（双端队列）、set（集合，基于红黑树实现）、map（映射，基于红黑树实现）等，它们是存储对象的模板类。 2. 迭代器（Iterators）：用于在...
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
MoView-VC.rar_mapobject_moview_visual c
09-23
本篇将深入探讨MapObject与MoView-VC在GIS二次开发中的应用，以及如何利用它们实现界面源代码。 首先，MapObject的核心优势在于其灵活性和兼容性。它能够与多种数据库系统集成，如ArcSDE、Oracle Spatial、MS SQL ...
C 语言 map实现
12-23
This is a simple hash table implementation in ANSI C. It supports the rudimentary functions generally expected of a hash table: Inserting and retrieving key-value associations Querying the existence of a key Returning the total number of key-value associations Iterating over all key-value associations
c 语言实现 map,C语言实现的HashMap
weixin_29944883的博客
05-19 1133
#include "c_map.h"void __c_map(c_pmap thiz, COMPARER keycmp){c_prb_tree ptree = (c_prb_tree)__c_malloc(sizeof(c_rb_tree));__c_rb_tree(ptree, keycmp);ptree->_A_keyofvalue = c_select1st();thiz->_l...
源码解析系列：HashMap(5) - c语言实现一个HashMap
Jwasx的博客
01-14 1254
文章目录1. 前言2. 开始C语言之旅 1. 前言 HashMap(5)中主要介绍了我的一个数据结构实验课设，而这个课设是实现一个HashMap，政整个HashMap的实现是以java JDK1.8的HashMap为参考实现的，其实说是参考，大部分其中的方法是和java源码一样的，在红黑树的方面则是自己设计的。对于这个课设，也有一些和HashMap不一样的地方，比如Key和Value都是使用int类型的，数组下标不再存放无头单链表，而是存放有头单链表，这其实都是其中一些坑，后来慢慢改成这样的。对于Ha..
C语言-手写有序Map(数组+链表+红黑树+有序遍历)(全功能)
weixin_45203607的博客
09-02 795
通过维护一条链表，解决了 HashMap 不能随时保持遍历顺序和插入顺序一致的问题。根据经验而已,单向链表足以,绝大部分场景根本不需要反向查询,所以我们只需要能保证按照插入的顺序进行迭代即可
C语言实现hashMap
xfxuezhang.cn
11-10 1万+
图中，紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。 下载链接：https://download.csdn.net/download/sxf1061700625/13101710 供参考学习 hashMap.h #ifndef _HASHMAP_H #define _HASHMAP_H typedef struct HashNode { char* key; ..
用C语言实现哈希表HashMap
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
01-14 1249
用C语言，基于动态数组+链表的形式实现的的HashMap
高质量C语言map实现
一把菜刀行江湖
02-11 830
扩展了github上比较经典的map实现，使得它可以支持原始的C语言类型作为键值
C语言hashmap实现
lengyue2015的博客
09-16 2031
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值进
unordered_map c实现
09-05
unordered_map 是 C++ 标准库中的一个容器，用于存储键值对，并支持快速的插入、删除和查找操作。C++ 的 unordered_map 可以通过哈希表来实现。 要在 C 中实现一个类似 unordered_map 的数据结构，你可以使用哈希表和链表的组合。下面是一个简单的示例： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define TABLE_SIZE 100 // 哈希表中的节点 typedef struct Node { char key[20]; int value; struct Node* next; } Node; // 哈希表 typedef struct HashMap { Node* table[TABLE_SIZE]; } HashMap; // 计算哈希值 int hash(const char* key) { int hash = 0; while (*key) { hash += *key; key++; } return hash % TABLE_SIZE; } // 初始化哈希表 HashMap* HashMap_Create() { HashMap* map = (HashMap*)malloc(sizeof(HashMap)); memset(map->table, 0, sizeof(map->table)); return map; } // 向哈希表中插入键值对 void HashMap_Insert(HashMap* map, const char* key, int value) { int index = hash(key); Node* newNode = (Node*)malloc(sizeof(Node)); strcpy(newNode->key, key); newNode->value = value; newNode->next = NULL; if (map->table[index] == NULL) { map->table[index] = newNode; } else { Node* current = map->table[index]; while (current->next != NULL) { current = current->next; } current->next = newNode; } } // 从哈希表中删除指定键的节点 void HashMap_Remove(HashMap* map, const char* key) { int index = hash(key); Node* current = map->table[index]; Node* previous = NULL; while (current != NULL && strcmp(current->key, key) != 0) { previous = current; current = current->next; } if (current == NULL) { return; // 未找到指定键的节点 } if (previous == NULL) { map->table[index] = current->next; } else { previous->next = current->next; } free(current); } // 从哈希表中获取指定键对应的值 int HashMap_Get(HashMap* map, const char* key) { int index = hash(key); Node* current = map->table[index]; while (current != NULL && strcmp(current->key, key) != 0) { current = current->next; } if (current == NULL) { return -1; // 未找到指定键的节点 } return current->value; } // 销毁哈希表 void HashMap_Destroy(HashMap* map) { for (int i = 0; i < TABLE_SIZE; i++) { Node* current = map->table[i]; while (current != NULL) { Node* next = current->next; free(current); current = next; } } free(map); } int main() { HashMap* map = HashMap_Create(); HashMap_Insert(map, "key1", 1); HashMap_Insert(map, "key2", 2); HashMap_Insert(map, "key3", 3); printf("value for key1: %d\n", HashMap_Get(map, "key1")); printf("value for key2: %d\n", HashMap_Get(map, "key2")); printf("value for key3: %d\n", HashMap_Get(map, "key3")); HashMap_Remove(map, "key2"); printf("value for key2: %d\n", HashMap_Get(map, "key2")); HashMap_Destroy(map); return 0; } ``` 这个示例演示了如何使用哈希表和链表组合来实现一个类似 unordered_map 的数据结构。你可以根据实际需求进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值