C语言实现LRU缓存

最新推荐文章于 2025-03-20 21:52:16 发布
置顶 最新推荐文章于 2025-03-20 21:52:16 发布
阅读量9k 收藏 23
点赞数 7
分类专栏： c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stand1210/article/details/70175792
版权

*本文简述一个简单LRU缓存的c语言实现方式。

GitHub:https://github.com/Stand1210/c-LRU-

一·首先明确几个概念：
1.缓存的特点？
    1⃣️：能在某种程度上降低访问数据的成本
    2⃣️：其容量远小于外部存储的容量。
2.什么是LRU缓存？
     LRU缓存是一种以LRU策略为缓存策略的缓存。
     所谓缓存策略， 就是当缓存满了之后， 又有新数据需要加入内存时， 我们怎么从缓存中为新数据腾出空间的策略。这个权衡的过程就是所谓的缓存策略。
     

     LRU, Least Recently Used的简写， 即近期最少使用算法。 该算法依据与程序的局部性原理， 其淘汰旧数据的策略是， 距离当前最久没有被访问过的数据应该被淘汰。

二·设计及实现
1⃣️ ：
LRUCache接口： 
//
//  LRUCache.h
//  LRU缓存接口
//
//  Created by 宋珂琦 on 2017/4/13.
//  Copyright © 2017年 宋珂琦. All rights reserved.
//

#ifndef LRUCache_h
#define LRUCache_h

/*创建LRU缓存*/
int LRUCacheCreate(int capacity, void **lruCache);
/*销毁LRU缓存*/
int LRUCacheDestory(void *lruCache);
/*将数据放入LRU缓存中*/
int LRUCacheSet(void *lruCache, char key, char data);
/*从缓存中获取数据*/
char LRUCacheGet(void *lruCache, char key);
/*打印缓存中的数据， 按访问时间从新到旧的顺序输出*/
void LRUCachePrint(void *lruCache);


#endif /* LRUCache_h */

   上述接口中， 我们假设数据索引和LRU缓存的每个单位仅能存储一个char型的字符。

2⃣️：详细设计

  •   使用双向链表维护LRU特性。
              我们将在缓存中维护一个双向链表， 该链表奖缓存中的数据块按访问时间从新到旧排列起来：
              1.当我们需要访问一块数据时， 我们先调用接口LRUCacheGet尝试从缓存中获取数据
              2.如果缓存中刚好缓存了该数据， 那么我们将该数据从缓存的双向链表中摘除， 然后再重新放入到双向链表的表头
              3.如果缓存中没有我们需要的数据， 那么我们从外部取得数据， 然后调用LRUCacheSet接口将该数据放入缓存， 此过程， 会将新数据插入到双向链表的表头
  • 使用哈希表保证缓存中数据的访问速度
            如果我们仅将缓存中的数据维护在一个链表中， 那么当我们需要从缓存中查找数据时， 旧意味着我们需要遍历链表。 这样的设计， 其时间复杂度为O(n). 是一种比较低效率的做法。 因此， 我们除了将数据维护在双向链表中， 我们同时还将数据维护在一个哈希表中。 哈希表访问数据的时间复杂度为O(1)。
            //注意  在我们的哈希表的实现内部， 也维护了链表， 这是一种解决哈希冲突的方法。如图：
         
  • 定义LRU缓存内部数据结构
            依据上述设计， 一个LRU缓存包含了一个双向链表和一个哈希表， 因此我们可以这样定义我们LRU缓存的数据结构
             
/* 定义LRU缓存 */
typedef struct LRUCacheS{
    int cacheCapacity;  /*缓存的容量*/
    cacheEntryS **hashMap;  /*缓存的哈希表*/
    
    cacheEntryS *lruListHead;   /*缓存的双向链表表头*/
    cacheEntryS *lruListTail;   /*缓存的双向链表表尾*/
    int lruListSize;    /*缓存的双向链表节点个数*/
}LRUCacheS;

           缓存中的单元， 既是一个双向链表节点， 同时又是哈希表当中的一个节点， 因此我们可以这样定义我们缓存单元的数据结构： 
/*定义LRU缓存的缓存单元*/
typedef struct cacheEntryS{
    char key;   /* 数据的key */
    char data;  /* 数据的data */
    
    struct cacheEntryS *hashListPrev;   /* 缓存哈希表指针， 指向哈希链表的前一个元素 */
    struct cacheEntryS *hashListNext;   /* 缓存哈希表指针， 指向哈希链表的后一个元素 */
    
    struct cacheEntryS *lruListPrev;    /* 缓存双向链表指针， 指向链表的前一个元素 */
    struct cacheEntryS *lruListNext;    /* 缓存双向链表指针， 指向链表后一个元素 */
}cacheEntryS;

           LRU缓存内部数据结构关系图如下：




三·测试程序
          我们以TDD（测试驱动开发）的方式来实现我们的LRU缓存， 在定义好接口后， 我们就可以先构造出我们的测试用例了： 
//
//  main.c
//  LRU 缓存测试用例
//
//  Created by 宋珂琦 on 2017/4/13.
//  Copyright © 2017年 宋珂琦. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>
#include "LRUCache.h"

/*错误处理宏*/
#define HANDLE_ERROR(msg) \
        do{ fprintf(stderr, "%s fail.\n", msg);exit(-1);}while(0);

/* 封装缓存数据存储接口， 此处我们让data同时充当key的角色 */
#define LRUCACHE_PUTDATA(cache, data) \
do {\
    if (0 != LRUCacheSet(cache, data, data)) {\
        fprintf(stderr, "put (%c %c) to cache fail. \n", data, data); \
    }else {\
        fprintf(stdout, "put (%c %c) to cache success.\n", data, data); \
    } \
} while (0);

/* 封装缓存数据存储接口 */
#define LRUCACHE_GETDATA(cache, key) \
do {\
    char data = LRUCacheGet(cache, key);\
    if ('\0' == data) \
        fprintf(stderr, "get data (Key: %c) from cache fail.\n", key);\
    else if (key == data) \
        fprintf(stdout, "get (%c, %c) from cache.\n", key, data);\
} while (0);


void testCase1(void)
{
    fprintf(stdout, "=================================\n");
    fprintf(stdout, "In testCase 1:\n");
    void *LruCache;
    if (0 != LRUCacheCreate(5, &LruCache)) {
        HANDLE_ERROR("LRUCacheCreate");
    }
    
    LRUCACHE_PUTDATA(LruCache, 'A');
    LRUCACHE_GETDATA(LruCache, 'A');
    
    LRUCACHE_PUTDATA(LruCache, 'B');
    LRUCACHE_GETDATA(LruCache, 'B');
    
    LRUCACHE_PUTDATA(LruCache, 'C');
    LRUCACHE_GETDATA(LruCache, 'C');
    LRUCachePrint(LruCache);
    
    LRUCACHE_PUTDATA(LruCache, 'D');
    LRUCACHE_GETDATA(LruCache, 'D');
    
    LRUCACHE_PUTDATA(LruCache, 'E');
    LRUCACHE_GETDATA(LruCache, 'E');
    
    LRUCACHE_PUTDATA(LruCache, 'A');
    LRUCACHE_GETDATA(LruCache, 'A');
    
    LRUCACHE_PUTDATA(LruCache, 'F');
    LRUCACHE_GETDATA(LruCache, 'F');
    
    LRUCachePrint(LruCache);
    
    LRUCACHE_PUTDATA(LruCache, 'F');
    LRUCACHE_GETDATA(LruCache, 'F');
    
    LRUCachePrint(LruCache);
    
    if (0 != LRUCacheDestory(LruCache))
        HANDLE_ERROR("LRUCacheDestory");
    
    fprintf(stdout, "In testCase 1 finished\n");
    fprintf(stdout, "=================================\n");
}

void testCase2()
{
    fprintf(stdout, "=================================\n");
    fprintf(stdout, "In testCase 2:\n");
    void *LruCache;
    if (0 != LRUCacheCreate(3, &LruCache)) {
        HANDLE_ERROR("LRUCacheCreate");
    }
    LRUCACHE_PUTDATA(LruCache, 'W');
    LRUCACHE_PUTDATA(LruCache, 'X');
    LRUCACHE_PUTDATA(LruCache, 'W');
    LRUCACHE_PUTDATA(LruCache, 'Y');
    LRUCACHE_PUTDATA(LruCache, 'Z');
    LRUCachePrint(LruCache);
    
    LRUCACHE_GETDATA(LruCache, 'Z');
    LRUCACHE_GETDATA(LruCache, 'Y');
    LRUCACHE_GETDATA(LruCache, 'W');
    LRUCACHE_GETDATA(LruCache, 'X');
    LRUCACHE_GETDATA(LruCache, 'W');
    LRUCachePrint(LruCache);
    
    /*YZWYX!*/
    LRUCACHE_PUTDATA(LruCache, 'Y');
    LRUCACHE_PUTDATA(LruCache, 'Z');
    LRUCACHE_PUTDATA(LruCache, 'W');
    LRUCACHE_PUTDATA(LruCache, 'Y');
    LRUCACHE_PUTDATA(LruCache, 'X');
    LRUCachePrint(LruCache);
    
    
    LRUCACHE_GETDATA(LruCache, 'X');
    LRUCACHE_GETDATA(LruCache, 'Y');
    LRUCACHE_GETDATA(LruCache, 'W');
    LRUCACHE_GETDATA(LruCache, 'Z');
    LRUCACHE_GETDATA(LruCache, 'Y');
    LRUCachePrint(LruCache); /*WYX*/
    
    /*XYXY!*/
    LRUCACHE_PUTDATA(LruCache, 'X');
    LRUCACHE_PUTDATA(LruCache, 'Y');
    LRUCACHE_PUTDATA(LruCache, 'X');
    LRUCACHE_PUTDATA(LruCache, 'Y');
    LRUCachePrint(LruCache);/*YX*/
    
    LRUCACHE_GETDATA(LruCache, 'Y');
    LRUCACHE_GETDATA(LruCache, 'X');
    LRUCACHE_GETDATA(LruCache, 'Y');
    LRUCACHE_GETDATA(LruCache, 'X');
    LRUCachePrint(LruCache); /*XY*/
    
    fprintf(stdout, "In testCase 2 finished\n");
    fprintf(stdout, "=================================\n");
}

void testCase3()
{
    fprintf(stdout, "=================================\n");
    fprintf(stdout, "In testCase 3:\n");
    void *LruCache;
    if (0 != LRUCacheCreate(5, &LruCache)) {
        HANDLE_ERROR("LRUCacheCreate");
    }
    LRUCACHE_PUTDATA(LruCache, 'E');
    LRUCACHE_PUTDATA(LruCache, 'I');
    LRUCACHE_PUTDATA(LruCache, 'E');
    LRUCACHE_PUTDATA(LruCache, 'I');
    LRUCACHE_PUTDATA(LruCache, 'O');
    LRUCachePrint(LruCache);
    
    LRUCACHE_GETDATA(LruCache, 'A');
    LRUCACHE_GETDATA(LruCache, 'I');
    LRUCACHE_GETDATA(LruCache, 'B');
    LRUCACHE_GETDATA(LruCache, 'O');
    LRUCACHE_GETDATA(LruCache, 'C');
    LRUCACHE_PUTDATA(LruCache, 'E');
    LRUCachePrint(LruCache);
    
    fprintf(stdout, "In testCase 3 finished\n");
    fprintf(stdout, "=================================\n");
}
int main()
{
    
    testCase1();
    testCase2();
    testCase3();
    return 0;
}


测试结果：
  • 测试用例1
  • 测试用例2
  • 测试用例3

缓存 c语言,C语言实现LRU缓存
weixin_28982257的博客
05-19 756
1.*下图用到双向链表和哈希表。双向链表即起到了随时遍历又起到了方便插入删除和数据改动。哈希表节省了保证缓存中数据的访问速度。2.*下图头文件中存放接口先从创建释放缓存单元->创建释放一个LRU缓存；双向链表删除指定节点接口->将节点插入到表头接口->释放整个链表接口->辅助性接口，用于保证最近访问的节点总是位于链表表头；哈希函数接口->向哈希表插入，删除缓存单元接口...
c语言实现的LRU算法
04-04
使用c语言是实现的LRU算法，带测试用例，供大家学习参考使用
C语言----设计LRU缓存结构
ftzchina的博客
08-01 471
用双向链表，头插法，思路很简单链表头是最常访问的地方，链表尾是最不常访问的地方： 1，如果操作为1，说明要加入到链表，插入到表头 2，如果操作为2，说明节点被访问，从当前节点删除并移动到表头 其中要考虑到缓冲区的大小，即链表长度，如果加入前链表长度已经到了最大，则需要删除链表尾节点，再加入 /** * lru design * @param operators int整型二维数组 the ops * @param operatorsRowLen int operator...
【数据结构与算法】LRU Cache
最新发布
m0_46676283的博客
03-20 811
LRU 是 Least Recently Used 的缩写，意思是最近最少使用，它是一种 Cache 替换算法。什么是Cache？狭义的 Cache 指的是位于 CPU 和主存间的快速 RAM（随机存取存储器）， 通常它不像系统主存那样使用 DRAM 技术，而使用昂贵但较快速的 SRAM 技术。广义上的Cache 指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
简单LRU算法实现缓存
庄周梦蝶
09-29 154
    最简单的LRU算法实现，就是利用jdk的LinkedHashMap，覆写其中的removeEldestEntry(Map.Entry)方法即可，如下所示： java 代码   import java.util.ArrayList;   import java.util.Collection;   import java.util.LinkedHashMap;  ...
C语言实现LRU缓存策略
嵌入式基地
07-19 920
今天主要给大家分享下基于C语言实现的LRU缓存淘汰算法。 缓存，是一种提高数据读取性能的技术，不论是在硬件，还是软件设计中都会被广泛的应用。 在软件设计中，缓存的大小总是有限的。当缓存被使用完时，就需要对数据进行清理。在清理数据时，经常会使用到缓存淘汰策略来决定清理哪些不需要的数据。 常见的策略有下面三种： 先进先出策略FIFO 最少使用策略LFU 最近最少使用策略LRU 一般采用链表实现LRU，基本的思路如下 首先需要在缓存中维护一个双向链表，链表中的数据按照访问的时间从新到旧排列。当有一个数据被
[力扣c语言实现] 146. LRU 缓存机制
dengwodaer的博客
05-12 654
146. LRU 缓存机制 1. 题目 146. LRU 缓存机制 难度中等1377收藏分享切换为英文接收动态反馈 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存
c语言实现LRU缓存.zip
06-13
LRU（Least Recently Used）缓存淘汰算法是一种常见的内存管理策略，用于在固定容量的缓存中决定何时替换数据。当缓存满时，最近最少使用的数据将被...通过理解和掌握这些内容，你可以自行编写一个高效的LRU缓存实现。
C语言实现LRU缓存算法的详细教程
本资源包包含了用C语言实现LRU缓存的完整代码和示例，旨在帮助读者深入理解LRU算法的工作原理和具体的编程实现方法。" 知识点: 1. LRU缓存概念：LRU缓存是一种根据数据的历史访问记录来进行管理的缓存算法。其核心...
c语言cache大小,C语言实现LRU缓存
weixin_29094539的博客
05-18 393
项目简介：该项目讲解如何使用C语言实现LRU缓存，从中学习LRU缓存的基本概念、C语言相关编程技巧，双向链表的C语言实现以及哈希表的C语言实现。学习知识点：LRU缓存的基本概念C语言基本编程技巧双向链表的C语言实现哈希表的C语言实现什么是缓存举个例子，去图书馆查资料，一般情况下我们会集中把我们有可能查阅的几本书从书架取下来，放在我们的桌面上，以便交叉查阅，从而避免频繁的从座位上跑到书架旁去取书。在...
LRU算法四种实现方式介绍
热门推荐
elricboa的专栏
12-19 20万+
LRU全称是Least Recently Used，即最近最久未使用的意思。 LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 实现LRU       1.用一个数组来存储数据，给每一个数据项标记一个访问时间戳，每次插入新数据项的时候，先把数组中存
lru算法C语言实现
12-16
C语言写的lru算法，验证过了，可以用。大概还是不错的
c语言的hash-lru实现
11-15
c语言的跨平台lru hash表; 经过简单测试,纯属娱乐. 怎么还不到50字
实现了LRU算法的缓存
05-03
用Java写的一个Cache，内部实现了LRU算法~
基于C语言的FIFO和LRU算法
06-15
基于C语言的FIFO和LRU算法的实现。
数据结构-LRU缓存（C语言实现）
pyc68的博客
10-01 1277
本篇文章主要是为了记录实现LRU缓存的方法和思考的过程。
C语言实现LRU缓存机制——哈希表+双向链表
weixin_42326997的博客
06-13 2201
题目描述 运用你所掌握的数据结构，设计和实现一个LRU（最近最少使用）缓存机制。它应该支持以下操作：获取数据get和写入数据 put。 获取数据get（key）-如果关键字（key）存在于缓存中，则获取关键字的值（总是正数），否则返回-1。 写入数据put（key，value）-如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组[关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 要求：时间复杂度为O（1）： 思路 1、一开始想的是用一
LRU算法 C语言简单实现
Serendipity_Shy
10-06 3204
C语言 数据结构与算法
【随笔系列】C语言实现LRU置换算法
究极小白-行者千面的博客
12-05 1500
LRU置换算法、C语言、操作系统实验
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值