LRU缓存实现

最新推荐文章于 2024-04-29 14:02:53 发布
最新推荐文章于 2024-04-29 14:02:53 发布
阅读量315 收藏
点赞数
分类专栏： 算法 文章标签： 缓存 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44054791/article/details/128417147
版权

1.题目描述

LRU(Least Recently Used)最近最少使用算法，通过淘汰最久为使用的缓存使缓存容量满足一致性
(1) LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
(2) int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
(3)void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
(4)函数 get 和 put 必须以 O(1) 的平均时间复杂度运行

2.例子

输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

3.思路

(1)使用双向链表，从虚拟头节点插入时，尾节点就是最久未使用的节点，头节点就是最新插入的节点。由于双向链表的特性，删除链表中的节点的时间复杂度是O(1)。
(2)构建一个key-value结构，可以记录put()方法插入的键值，以及对应的节点地址，从而方便找到双向链表中的对应节点，此hash表结构为key(键)-value(值，对应节点地址)
(3)对于get(key)方法，需要满足获取到get(key)的值后，将双向链表的对应节点删除，并且重新从虚拟头节点后加入，然后维护hash表结构，记录key(键)-value(值，对应节点地址)
(4)对于put(key,value)方法，需要分类讨论
1)容量未满时，key值已经存在时，删除双向链表中对应节点，从虚拟头节点后再次加入，然后维 护hash表结构
key值不存在(新的key，value)，创建新的节点，直接从双向链表中的虚拟头节点后加入，维护hash表结构
2）容量已满，key值已经存在时，删除双向链表中对应节点，从虚拟头节点后再次加入，然后维 护hash表结构
key值不存在(新的key，value)，需要将双向链表尾节点删除，维护hash表中的信息(删除过期系欸但信息)，然后创建新节点，直接从双向链表中的虚拟头节点后加入，维护hash表结构(增加新节点信息)

4.代码

class LRUCache {
private:
    struct Node{//双向链表的节点信息
        int key = -1;
        int val = -1;
        Node* pre = NULL;
        Node* next = NULL;
    };

    struct element{// hash表中的元素信息
        int val = -1;
        Node* addr = NULL;
    };

    Node* VirtualNode;// 链表的虚拟头节点
    Node* tailNode; // 链表的尾节点

    int size = 0;// 记录链表长度
    int capacity;// 容量
    
    unordered_map<int,element> mp; // hash表
    
public:
    LRUCache(int capacity) {
        
        this->capacity = capacity; // 初始化容量
        this->VirtualNode = new Node(); // 初始化虚拟头节点
        this->tailNode = this->VirtualNode;
    }

    void addLinkedList(Node* node){//从头插入节点
        if(VirtualNode->next == NULL){
            VirtualNode->next = node;
            node->pre = VirtualNode;
        }else{
            Node* temp = VirtualNode->next;
            node->next = temp;
            node->pre = VirtualNode;

            VirtualNode->next = node;
            temp->pre = node;

        }
   
        // 维护尾指针，第一次插入的节点为尾指针
        if(size == 0){
            tailNode = node;
        }
        size++;   
    }

    void removeLinkedList(Node* node){//删除某个节点，使用双向链表可以找到该节点的前一个和后一个节点

        Node* preNode = node->pre;
        Node* nextNode = node->next;

        // 需要删除的节点是尾节点
        if(node == tailNode){
            preNode->next = NULL;
            tailNode = preNode;// 维护尾节点
        }else{
            preNode->next = nextNode;
            nextNode->pre = preNode;
        }
        size--;
    }
    
    int get(int key) {
        // 没有节点或需要查询的节点已经过期
        if( size == 0 || mp[key].val == -1){
            return -1;
        } 
        else{// 如果节点过期，需要将hash表中的val值置为-1，此时链表中已经不存在该节点，无法完成删除操作
            // 更新链表，使得尾节点是最近最少使用的节点，头节点是最近使用过的节点
            // 删除mp[key].addr节点，并且从头插入此节点
            removeLinkedList(mp[key].addr);
            addLinkedList(mp[key].addr);
            return mp[key].val;
        }
    }
    
    void put(int key, int value) {
        
        // 链表长度小于capacity
        if(this->size < this->capacity){
            // 如果key值存在过了
            if(mp[key].val != -1){
                // 将链表中的mp[key].addr节点删除，重新添加
                removeLinkedList(mp[key].addr);
                addLinkedList(mp[key].addr);
                // 维护hash表，更新val
                mp[key].val = value;
            }else{//key值之前未添加过，添加新的key值
                // 创建新节点
                Node* node =  new Node;
                node->key = key;
                node->val = value;
                //向链表中添加新节点node
                addLinkedList(node);
                //维护hash表
                mp[key].val = value; 
                mp[key].addr = node;
            }  
        }else{//链表长度超过容量

            // 如果之前key值存在过了，不产生新节点
            if(mp[key].val != -1){
                // 将链表中的mp[key].addr节点删除，重新添加
                removeLinkedList(mp[key].addr);
                addLinkedList(mp[key].addr);
                //维护hash表
                mp[key].val = value; 

            }else{// 如果之前key值不存在，产生新节点

                // 维护hash表,节点过期
                mp[tailNode->key].val = -1;
                
                // 删除链表尾部节点（最近最少使用）
                removeLinkedList(tailNode);

                // 创建新节点
                Node* node = new Node;
                node->key = key;
                node->val = value;
                
                // 添加新节点
                addLinkedList(node);

                // 维护hash表
                mp[key].val = value; 
                mp[key].addr = node;

            }
        }
    }
};

可见在向LinkedList中加入元素后，都需要维护hash表，所以代码可以调整，并且使用stl中的list结构代替自己编写的双向链表，从而减少代码量

class LRUCache {
private:
    struct element{// hash表中的元素信息
        int val = -1;
        list<int>::iterator addr;
    };

    list<int> LinkedList;//使用双向链表
    // int size = 0;// 记录链表长度，由于list.size()函数的时间复杂度是O(N),可以通过维护一个size()值减少此处的时间消耗
    int capacity;// 容量
    unordered_map<int,element> mp; // hash表
    
public:
    LRUCache(int capacity) {
        this->capacity = capacity; // 初始化容量
    }
    
    int get(int key) {
        // 没有节点或需要查询的节点已经过期
        if( LinkedList.size() == 0 || mp[key].val == -1){
            return -1;
        } 
        else{// 如果节点过期，需要将hash表中的val值置为-1，此时链表中已经不存在该节点，无法完成删除操作
            // 更新链表，使得尾节点是最近最少使用的节点，头节点是最近使用过的节点
            // 删除mp[key].addr节点，并且从头插入此节点
            LinkedList.erase(mp[key].addr);
            LinkedList.push_front(key);
            mp[key].addr = LinkedList.begin();
            return mp[key].val;
        }
    }
    
    void put(int key, int value) {
        // 链表长度小于capacity
        if(LinkedList.size() < this->capacity){
            // 如果key值存在过了
            if(mp[key].val != -1){
                // 将链表中的mp[key].addr节点删除，重新添加
                LinkedList.erase(mp[key].addr);
                LinkedList.push_front(key);
            }else{//key值之前未添加过，添加新的key值
                //向链表中添加新节点node
                LinkedList.push_front(key);
            } 

        }else{//链表长度超过容量
            // 如果之前key值存在过了，不产生新节点
            if(mp[key].val != -1){
                // 将链表中的mp[key].addr节点删除，重新添加
                LinkedList.erase(mp[key].addr);
                LinkedList.push_front(key);
            }else{// 如果之前key值不存在，产生新节点
                // 维护hash表,节点过期
                mp[LinkedList.back()].val = -1;
                // 删除链表尾部节点（最近最少使用）
                LinkedList.pop_back();
                // 添加新节点
                LinkedList.push_front(key);
            }
        }
        // 维护hash表，更新val
        mp[key].val = value;
        mp[key].addr = LinkedList.begin();
    }
};

注：list结构的list.size()方法的时间复杂度为O(n)，因为其内部调用了distance()方法计算了所有元素的个数，因此可以使用size变量得到双向链表得长度

cl~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Java实现LRU缓存
08-18
主要介绍了详解Java实现LRU缓存，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
实现 LRU 缓存算法
cr7258的博客
05-18 4117
1 LRU 缓存介绍 LRU 算法全称是最近最少使用算法（Least Recently Use），是一种简单的缓存策略。顾名思义，LRU 算法会选出最近最少使用的数据进行淘汰。 那么什么是缓存呢？缓存专业点可以叫一种提高数据读取性能的技术，可以有效解决存储器性能和容量的矛盾，是一种空间换时间的设计思想，比如我们常见的内存是硬盘的缓存，Cache 是内存的缓存，浏览器本地存储是网络访问的缓存...... LRU 有许多应用场景，例如： 操作系统底层的内存管理。 缓存服务，例如 Redis，当数据满的时候就要
lru-cache:带最小堆的 LRU 缓存实现
06-07
#LRU 缓存 描述：这个项目有点像实验，涉及 3 种不同的 LRU 缓存实现。 一个使用最小堆（通常用于优先级队列）而不是 OrderedDict，第二个使用集合包中的内置 OrderedDict，最后一个使用我自己的 OrderedDict 的简单实现。 观察：所有三个 LRU 缓存都有相同的测试。 我在缓存中运行了一些容量为 5 000 000 个元素的规模测试，并添加了额外的 500 002 个元素。 显然，最小堆对于插入、更新和删除有一个大 O(log n)，所以它比有一个大 O(1) 的 OrderedDict 慢得多。 也就是说，在达到缓存容量之前，最小堆实际上会稍微快一点。 对具有 5 000 000 个元素容量的 3 个不同缓存进行分析： 插入元素的数量 最小堆 有序字典 我的字典 5 000 001 x 2 次测试 47.626s 52.375s 59.921
实现一个LRU缓存
CodingMayCry
08-29 694
什么是LRU算法？ 就是一种缓存淘汰策略。 LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 LRU 算法实际上是让你设计数据结构：首先要接收一个 capacity 参数作为缓存的最大容量，然后实现两个 API，一个是 put(key, val) 方法存入键值对，另一...
【常见缓存算法原理及其C++实现】LRU篇（包含过期时间详解）
saxon_li的博客
04-05 6447
一、缓存算法简介 （一）缓存算法应用背景 缓存的应用场景和范围十分广泛，下面给出其十分常见的两种应用背景： 首先，在操作系统内部，由于内存资源十分有限，而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制，它将进程的一部分内容暂留在磁盘中，在需要时再进行数据交换将其放入内存，这个过程就需要用到缓存算法机制进行置换。 其次，对于各类应用项目开发而言，在巨大的数据量面前，Catch 是不可或缺的。因为无论是针对本地端的浏览器缓存，还...
Lru缓存算法的简易设计及实现
weixin_72125569的博客
09-08 951
Lru缓存算法设计及使用
LRU 缓存的两种实现方式
anhooo的博客
06-26 485
LRU 缓存的两种实现方式 一、使用LinkedHashMap实现 class LRUCache { Map<Integer, Integer> cache=null; public LRUCache(int capacity) { cache = new LinkedHashMap<>(capacity, 0.75f, true){ @Override public boolean remov
LRU缓存实现与原理
KeaLoo
09-14 933
概念 LRU是 Least Recently Used 的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的，是根据页面调入内存后的使用情况进行决策了。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU算法就是将最近最久未使用的页面予以淘汰。 操作系统里，在内存不够的场景下，淘汰旧内容的策略。LRU … Least Recent Used，淘汰掉最不经常使用的。因为计算机体系结构中，最大的最可靠的存储是硬盘，容量很大，并且内容可以固化，但是访问速
动手实现一个 LRU Cache
qq_47539679的博客
04-02 137
LeetCode146.LRU 缓存。请你设计并实现一个满足。
如何实现高效的缓存策略：LRU缓存
m0_75198698的博客
06-04 358
LRU（Least Recently Used，最近最少使用）缓存是一种常用的缓存策略，它根据数据项的访问顺序来确定哪些数据项是最近最少使用的，从而进行缓存的替换。需要注意的是，在多线程环境下，对缓存的并发访问需要进行同步操作，以确保线程安全性。如果缓存已满，需要删除链表尾部的数据项，并将新数据项添加到链表头部。- 当缓存达到容量上限并且需要替换数据项时，可以选择删除链表尾部的数据项，因为它是最近最少使用的。- 在哈希表中快速找到要删除的数据项，并更新链表的前后指针，保持链表的连续性。
php-lrucache:PHP中的LRU缓存实现
07-08
PHP LRU缓存实现介绍WTF 是 LRU 缓存吗？ LRU 代表最近最少使用。 它是一种缓存类型，通常具有固定容量并丢弃最旧的条目。 如果您需要控制缓存内存使用，这将特别有用。 如果您想了解有关 LRU Cache 的更多详细信息...
uluru:一个简单，快速的LRU缓存实现
05-16
一种简单，快速，最近最少使用（LRU）的缓存实现，用于Servo的样式系统。 LRUCache使用固定容量的阵列进行存储。 它提供O(1)插入和O(n)查找。 它不需要分配器，可以在no_std包装箱中使用。 它在100％安全的Rust中...
lru-cache：C ++中功能完整的LRU缓存实现
02-05
lru-cache：C ++中功能完整的LRU缓存实现
c++理论篇(一) ——浅谈tcp缓存与tcp的分包与粘包
qq_73924465的博客
04-27 1301
在TCP协议中，无论发送多少数据，都要在数据前面加上协议头，同时，对方收到数据后，也需要回复ACK表示确认。为了尽可能的利用网络带宽，TCP希望每次都能够以MSS（Maximum Segment Size，最大报文长度）的数据块来发送数据。这一篇文章主要是为下一篇网络编程的服务端与客户端编写做一个引子,介绍一些有关网络编程的基本知识，因为下一篇文章将会给大家介绍在c++网络编程中有关服务端与客户端的编写,本文只做一些理论介绍，大家下篇见！
redis 使用互斥锁或逻辑过期两种方案解决缓存击穿，和缓存穿透(用缓存空值 或布隆过滤器)的解决方案
小哇
04-28 885
缓存击穿是指一个被频繁访问（高并发访问并且缓存重建业务较复杂）的缓存键因为过期失效，同时又有大量并发请求访问此键，导致请求直接落到数据库或后端服务上，增加了系统的负载并可能导致系统崩溃。缓存穿透是指在缓存中查找一个不存在的值，由于缓存一般不会存储这种无效的数据，所以每次查询都会落到数据库上，导致数据库压力增大，严重时可能会导致数据库宕机。4 做好数据的基础格式校验。缓存空值 (本文此方案。5 做好热点参数的限流。3 增强id的复杂度。
NDK 入门（四）—— 静态缓存与 Native 异常
tmacfrank的博客
04-28 1785
throw "我报废了";// 更加简单的写法 自定义异常public:return "自定义";Student s;throw s;try {// 抛的是 const char *，因此捕获也是这种类型cout
Python异步Redis客户端与通用缓存装饰器
qq_43629857的博客
04-29 1026
通过 redis-py 简易封装一个异步的Redis客户端，然后主要讲解设计一个支持各种缓存代理（本地内存、Redis等）的缓存装饰器，用于在减少一些不必要的计算、存储层的查询、网络IO等。
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
05-04
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
各地区年末城镇登记失业人员及失业率.xls
最新发布
05-05
数据来源：中国劳动统计NJ-2023版
lru 缓存 c++ 设计实现
06-09
LRU 缓存是一种常见的缓存淘汰算法，它的设计思想是将最近最少使用的数据从缓存中淘汰出去，以保证缓存的数据都是热点数据，从而提高缓存的命中率。 下面是一个基于双向链表和哈希表实现的 LRU 缓存的 C++ 设计实现： ```cpp #include <unordered_map> struct Node { int key; int value; Node* prev; Node* next; Node(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {} }; class LRUCache { public: LRUCache(int capacity) : size_(capacity), head_(nullptr), tail_(nullptr) {} int get(int key) { auto iter = cache_.find(key); if (iter == cache_.end()) { return -1; } else { Node* node = iter->second; move_to_head(node); return node->value; } } void put(int key, int value) { auto iter = cache_.find(key); if (iter == cache_.end()) { Node* node = new Node(key, value); add_to_head(node); cache_[key] = node; if (cache_.size() > size_) { Node* tail = remove_tail(); cache_.erase(tail->key); delete tail; } } else { Node* node = iter->second; node->value = value; move_to_head(node); } } private: int size_; Node* head_; Node* tail_; std::unordered_map<int, Node*> cache_; void add_to_head(Node* node) { if (head_ == nullptr) { head_ = node; tail_ = node; } else { node->next = head_; head_->prev = node; head_ = node; } } void move_to_head(Node* node) { if (node == head_) { return; } else if (node == tail_) { tail_ = tail_->prev; tail_->next = nullptr; } else { node->prev->next = node->next; node->next->prev = node->prev; } node->next = head_; head_->prev = node; node->prev = nullptr; head_ = node; } Node* remove_tail() { Node* node = tail_; if (head_ == tail_) { head_ = nullptr; tail_ = nullptr; } else { tail_ = tail_->prev; tail_->next = nullptr; } return node; } }; ``` 在这个实现中，我们使用了一个双向链表保存缓存中的数据，并使用一个哈希表来提高查找效率。在 `get` 操作中，如果缓存中不存在目标数据则返回 -1，否则将目标数据移到链表头部并返回其值。在 `put` 操作中，如果缓存中不存在目标数据则创建一个新的节点并将其添加到链表头部，如果缓存已满则删除链表尾部的节点。如果缓存中已存在目标数据则将其值更新并将其移动到链表头部。 需要注意的是，在 `move_to_head` 和 `remove_tail` 操作中，我们需要判断目标节点是否已经在链表的头部或尾部，以避免对空指针进行操作。此外，在每次操作中，我们还需要更新哈希表中对应节点的指针。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值