c语言实现带LRU机制的哈希表

最新推荐文章于 2024-10-01 23:38:02 发布
最新推荐文章于 2024-10-01 23:38:02 发布
阅读量99 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/danxi/p/6727142.html
版权 
  1 #include <stdint.h>
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <string.h>
  5 
  6 #define HASH_BUCKET_MAX (1024)
  7 #define HASH_BUCKET_CAPACITY_MAX (256)
  8 #define HASHTABLE_DEBUG
  9 #define TRUE  1
 10 #define FALSE 0
 11 
 12 #ifdef HASHTABLE_DEBUG
 13 #define DEBUG(format, ...) printf("[%s] [%d] : "format"\n", __FUNCTION__, __LINE__, __VA_ARGS__)
 14 #else
 15 #define DEBUG(format, ...)
 16 #endif
 17 
 18 struct hash_bucket {
 19     int                capacity;  /* 桶的容量 */
 20     void               *hkey;     /* hashtable的key */
 21     void               *hdata;    /* hashtable的data */
 22     struct hash_bucket *prev;
 23     struct hash_bucket *next;
 24     struct hash_bucket *tail;
 25 };
 26 
 27 struct hash {
 28     uint32_t            (*hash_key)(void *);
 29     int                 (*hash_cmp)(const void *, const void*, int len);
 30     struct hash_bucket* bucket[HASH_BUCKET_MAX];
 31 };
 32 
 33 uint32_t string_hash_key(void* str);
 34 int string_hash_cmp(const void* src, const void* dst);
 35 
 36 static struct hash *g_htable = NULL;
 37 
 38 void hash_create();
 39 void *hash_lookup(void *key);
 40 int  hash_add(void *key, void* data);
 41 int  hash_delete(void *key);
 42 void hash_destroy();
 43 void hash_iter_print();
 44 
 45 #define  bucket_free(bucket) \
 46     free(bucket->hkey);      \
 47     free(bucket->hdata);     \
 48     free(bucket);            \
 49     bucket = NULL;
 50 
 51 uint32_t string_hash_key(void* str) {
 52     char *tmp = (char *)str;
 53     uint32_t key = 0;
 54     while(*tmp)
 55         key = (key * 33) ^ (uint32_t)(tmp++);
 56 
 57     DEBUG("string key : %u, index : %d", key, key%HASH_BUCKET_MAX);
 58 
 59     return key%HASH_BUCKET_MAX;
 60 }
 61 
 62 int string_hash_cmp(const void* src, const void* dst, int len) {
 63     if (!src || !dst) {
 64         DEBUG("src addr: %p, dst addr: %p", src, dst);
 65         return -1;
 66     }
 67     return strncmp((char *)src, (char *)dst, len);
 68 }
 69 
 70 void hash_create() {
 71     if (g_htable) {
 72         DEBUG("the default hashtable is already created");
 73         return;
 74     }
 75     
 76     g_htable = (struct hash *)malloc(sizeof(struct hash));
 77     if (!g_htable) {
 78         DEBUG("memory alloc failed.");
 79         return;
 80     }
 81 
 82     memset(g_htable, 0, sizeof(struct hash));
 83 
 84     g_htable->hash_key = string_hash_key;
 85     g_htable->hash_cmp = string_hash_cmp;
 86 
 87     return;
 88 }
 89 
 90 static void bucket_delete(struct hash_bucket** ptr) {
 91     struct hash_bucket *bucket = *ptr;
 92     struct hash_bucket *tmp;
 93 
 94     while(bucket) {
 95         tmp = bucket;
 96         bucket = bucket->next;
 97         bucket_free(tmp);
 98     }
 99 }
100 
101 void hash_destroy() {
102     if (g_htable) {
103         for(int i=0; i<HASH_BUCKET_MAX; i++) {
104             if (g_htable->bucket[i]) {
105                 bucket_delete(&g_htable->bucket[i]);
106             }
107         }
108         
109         free(g_htable);
110         g_htable = NULL;
111     }
112     return;
113 }
114 
115 #define  lru_bucket_move(bucket,  head)   \
116     bucket->next = head;                  \
117     bucket->prev = NULL;                  \
118     bucket->capacity = head->capacity;    \
119                                           \
120     head->prev = bucket;                  \
121     head->tail = NULL;    
122 
123 void *hash_lookup(void *key) {
124     if (!key) {
125         DEBUG("input para is NULL\n");
126         return NULL;
127     }
128 
129     uint32_t index = g_htable->hash_key(key);
130     struct hash_bucket* head = g_htable->bucket[index];
131     struct hash_bucket* bucket = head;
132 
133     while(bucket) {
134         if (0 == g_htable->hash_cmp(key, bucket->hkey, strlen((char*)key))) {
135             if (head != bucket && bucket != head->tail) {
136                 bucket->prev->next = bucket->next;
137                 bucket->next->prev = bucket->prev;
138                 bucket->tail = head->tail;
139 
140                 lru_bucket_move(bucket, head);
141             } else if (bucket == head->tail && head->capacity>1) {
142                 bucket->prev->next = NULL;
143                 bucket->tail = bucket->prev;
144 
145                 lru_bucket_move(bucket, head);
146             }
147             g_htable->bucket[index] = bucket;
148             return bucket->hdata;
149         }
150         bucket = bucket->next;
151     }
152     return NULL;
153 }
154 
155 int hash_add(void *key, void* data) {
156     if (!key || !data) {
157         DEBUG("input para is NULL\n");
158         return FALSE;
159     }
160 
161     uint32_t index = g_htable->hash_key(key);
162     struct hash_bucket* head = g_htable->bucket[index];
163 
164     if (!head) {
165         head = (struct hash_bucket*)malloc(sizeof(struct hash_bucket));
166         if (!head) {
167             DEBUG("no memory for more hash_bucket\n");
168             return FALSE;
169         }
170 
171         memset(head, 0, sizeof(*head));
172         head->capacity++;
173         
174         head->hkey  = strdup((char *)key);
175         head->hdata = strdup((char *)data);        
176         head->tail  = head;
177         g_htable->bucket[index] = head;
178         return TRUE;
179     }
180 
181     int capacity = head->capacity;
182     struct hash_bucket *new_bucket = 
183         (struct hash_bucket *)malloc(sizeof(struct hash_bucket)); 
184 
185     if (!new_bucket) {
186         DEBUG("no memory for more hash_bucket\n");
187         return FALSE;
188     }
189 
190     if (capacity >= HASH_BUCKET_CAPACITY_MAX) {
191         struct hash_bucket *tail = head->tail;
192         head->tail = tail->prev;
193 
194         tail->prev->next = NULL;
195         bucket_free(tail);
196     } 
197     
198     head->prev = new_bucket;
199     new_bucket->next = head;
200     new_bucket->capacity = capacity + 1;
201     new_bucket->tail = head->tail;
202     head->tail = NULL;
203 
204     head->hkey  = strdup((char *)key);
205     head->hdata = strdup((char *)data);
206     
207     g_htable->bucket[index] = new_bucket;
208     
209     return TRUE;
210 }
211 
212 int hash_delete(void *key) {
213     if (!key) {
214         DEBUG("input para is NULL\n");
215         return FALSE;
216     }
217 
218     uint32_t index = g_htable->hash_key(key);
219     struct hash_bucket* head = g_htable->bucket[index];
220     struct hash_bucket* bkt = head;
221 
222     while(bkt) {
223         if (0 == g_htable->hash_cmp(key, bkt->hkey, strlen((char*)key))) {
224             if (head != bkt && bkt != head->tail) {
225                 bkt->prev->next = bkt->next;
226                 bkt->next->prev = bkt->prev;
227 
228             } else if (bkt == head->tail && head->capacity>1) {
229                 bkt->prev->next = NULL;
230                 bkt->tail = bkt->prev;
231 
232             } else {
233                 if (bkt->next) {
234                     bkt->next->tail = bkt->tail;
235                     bkt->next->capacity = bkt->capacity;
236                     bkt->next->prev = NULL;
237                     g_htable->bucket[index] = bkt->next;
238                 } else {
239                     g_htable->bucket[index] = NULL;
240                 }
241             }
242 
243             bucket_free(bkt);
244             if (g_htable->bucket[index]) {
245                 g_htable->bucket[index]->capacity--;
246             }
247             
248             return TRUE;
249         }
250         bkt = bkt->next;
251     }
252     return FALSE;
253 }
254 
255 static void bucket_print(struct hash_bucket** ptr) {
256     struct hash_bucket *bkt = *ptr;
257     struct hash_bucket *tmp;
258 
259     while(bkt) {
260         printf("key=[%s],data=[%s]\n", (char*)bkt->hkey, (char*)bkt->hdata);
261         bkt = bkt->next;
262     }
263 }
264 
265 void hash_iter_print() {
266     if (g_htable) {
267         for(int i=0; i<HASH_BUCKET_MAX; i++) {
268             if (g_htable->bucket[i]) {
269                 bucket_print(&g_htable->bucket[i]);
270             }
271         }
272     }
273 }
274 
275 int main(int argc, char* argv[]) {
276     hash_create();
277 
278     hash_add("first", "danxi");
279     hash_add("second", "test");
280     hash_add("three", "sad code");
281     hash_add("four", "let's go");
282 
283     hash_iter_print();
284 
285     char * t1 = (char *)hash_lookup("first");
286     char * t2 = (char *)hash_lookup("second");
287 
288     printf("%s  %s \n", t1, t2);
289     printf("%s \n", (char*)hash_lookup("four"));
290 
291     hash_delete("four");
292     hash_iter_print();
293     hash_destroy();
294 
295     return 0;
296 }

 

转载于:https://www.cnblogs.com/danxi/p/6727142.html

weixin_30950887
关注
缓存 c语言,C语言实现LRU缓存
weixin_28982257的博客
05-19 731
1.*下图用到双向链表和哈希表。双向链表即起到了随时遍历又起到了方便插入删除和数据改动。哈希表节省了保证缓存中数据的访问速度。2.*下图头文件中存放接口先从创建释放缓存单元->创建释放一个LRU缓存；双向链表删除指定节点接口->将节点插入到表头接口->释放整个链表接口->辅助性接口，用于保证最近访问的节点总是位于链表表头；哈希函数接口->向哈希表插入，删除缓存单元接口...
【随笔系列】C语言实现LRU置换算法
究极小白-行者千面的博客
12-05 1418
LRU置换算法、C语言、操作系统实验
c语言实现的LRU算法
04-04
使用c语言是实现的LRU算法，带测试用例，供大家学习参考使用
c语言的hash-lru实现
11-15
c语言的跨平台lru hash表; 经过简单测试,纯属娱乐. 怎么还不到50字
数据结构-LRU缓存（C语言实现）
最新发布
pyc68的博客
10-01 1051
本篇文章主要是为了记录实现LRU缓存的方法和思考的过程。
lru算法C语言实现
12-16
C语言写的lru算法，验证过了，可以用。大概还是不错的
LRU算法 C语言简单实现
Serendipity_Shy
10-06 2965
C语言 数据结构与算法
c语言实现LRU缓存.zip
06-13
C语言实现LRU缓存涉及到数据结构的设计、哈希表和链表的应用，以及高效的内存管理。以下是对这个主题的详细讲解： 1. **LRU算法原理**： LRU算法基于“最近使用频率越高，将来越可能再次被使用”的假设。在缓存中...
C语言实现LRU缓存
Stand1210的博客
04-14 8932
1
基于C语言的FIFO和LRU算法
06-15
基于C语言的FIFO和LRU算法的实现。
LRU的实现代码（C语言编写）
05-08
自己写的，虽然比较简单，但已经实现了LRU的思想
C语言实现LRU缓存策略
嵌入式基地
07-19 898
今天主要给大家分享下基于C语言实现的LRU缓存淘汰算法。 缓存，是一种提高数据读取性能的技术，不论是在硬件，还是软件设计中都会被广泛的应用。 在软件设计中，缓存的大小总是有限的。当缓存被使用完时，就需要对数据进行清理。在清理数据时，经常会使用到缓存淘汰策略来决定清理哪些不需要的数据。 常见的策略有下面三种： 先进先出策略FIFO 最少使用策略LFU 最近最少使用策略LRU 一般采用链表实现LRU，基本的思路如下 首先需要在缓存中维护一个双向链表，链表中的数据按照访问的时间从新到旧排列。当有一个数据被
C语言实现LRU缓存机制——哈希表+双向链表
weixin_42326997的博客
06-13 1943
题目描述 运用你所掌握的数据结构，设计和实现一个LRU（最近最少使用）缓存机制。它应该支持以下操作：获取数据get和写入数据 put。 获取数据get（key）-如果关键字（key）存在于缓存中，则获取关键字的值（总是正数），否则返回-1。 写入数据put（key，value）-如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组[关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 要求：时间复杂度为O（1）： 思路 1、一开始想的是用一
LRU页面置换算法（C语言实现）
热门推荐
qq_50829760的博客
11-12 1万+
编写并调试一个页面置换模拟程序，采用LRU（最近最久未使用页面置换）算法。已知系统为一进程分配的物理块数，进程运行过程中引用的页面号，编程使用LRU算法输出置换的页号、缺页中断次数及缺页率。
c语言用单链表实现lru算法,利用单链表实现LRU算法
weixin_42354108的博客
05-23 196
利用单链表实现LRU算法首先，我们先看下对于Node的定义：package datastructure.linklist.node;import lombok.Data;/*** 单链表节点* @author BiggerShen* @date 2020/3/25*/@Datapublic class SingletonNode {private T data;private SingletonN...
使用C++简单实现LRU缓存
Milan_1in的博客
03-29 2135
使用C++简单实现LRU缓存   昨天碰巧复习到了LRU缓存机制，也就是最近最少使用，在好奇心的驱动下我想到了用C++简单的实现一下，本来原理也挺简单的，写出来并不难，但由于对C++的基础把握不劳，结果排查了好长时间的bug。现在总结一下，希望能帮到别的小可爱。 首先是malloc:   可能是C语言写习惯的，导致在C++进行内存分配的时候我也习惯用malloc，C和C++混用很可能就会出b...
2021-06-06 操作系统LRU算法C语言实现
APPDREAMER的博客
06-06 1795
操作系统LRU算法C语言实现 前言 本机为微软Surface pro4，为64位，所用操作系统为Windos 10。本机虚拟机版本为Oracle VM VirtualBox 6.1.8，所用操作系统是使用Ubuntu18.04，。Ubuntu的虚拟硬盘设置为200G，显存为128MB，内存为4G，CPU2个，所用镜像源为清华大学软件镜像源。所使用linux内核为linux-5.11.8。 注意事项 （1）本LRU算法的实现思路是借鉴网上的相关资源，并非原创。 （2）本篇博客代码只实现LRU算法的置换显示，.
利用哈希表来实现LRU页面置换算法C语言
06-13
好的，下面是一个利用哈希表和双向链表实现LRU页面置换算法的C语言代码示例： ```c #include #include #define CACHE_CAPACITY 5 // 缓存容量为5 // 定义缓存节点 typedef struct CacheNode { int key; // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值