LeetCode 算法：LRU 缓存 c++

最新推荐文章于 2024-09-22 11:22:10 发布
最新推荐文章于 2024-09-22 11:22:10 发布
阅读量992 收藏 21
点赞数 16
分类专栏： # 力扣 文章标签： 算法 leetcode LRU 缓存 哈希表 双向链表 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanceyxin/article/details/139899194
版权

原题链接🔗：
难度：中等⭐️⭐️

题目

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
[“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

提示：

  • 1 <= capacity <= 3000
  • 0 <= key <= 10000
  • 0 <= value <= 105
  • 最多调用 2 * 105 次 get 和 put

题解

  1. 解题思路：

LeetCode 上的 LRU 缓存问题（题目编号 146）要求我们实现一个 LRU 缓存类，该类支持两种操作：get 和
put。以下是解决这个问题的一般思路：

  • 理解问题：
    • get(key): 从缓存中获取键对应的值（如果存在）。缓存中键的最近使用时间应该被更新为当前时间。 -
    • put(key, value): 向缓存中插入或更新键和值。如果键已存在，则更新其值并更新其使用时间。如果键不存在，并且缓存已满，则需要先移除最久未使用的键。
  • 设计数据结构： 为了实现 LRU 缓存，我们需要两个主要的数据结构：
    • 哈希表：存储键到值的映射，以及键到双向链表中节点的引用，以便 O(1) 时间复杂度的访问。
    • 双向链表：存储缓存项的顺序，最近使用的项在头部，最久未使用的项在尾部。
  • 算法实现：
    • 初始化：创建一个固定大小的哈希表和空的双向链表。
    • get(key)： 检查键是否存在于哈希表中。 如果存在，移动该键关联的节点到双向链表的头部，表示最近使用。 返回键对应的值。 如果不存在，返回 -1。
    • put(key, value)：
      • 如果键已存在于哈希表中，更新其值，并将节点移动到双向链表的头部。
      • 如果键不存在：
        • 如果缓存未满，创建新节点，添加到双向链表的头部，并在哈希表中添加键到节点的映射。
        • 如果缓存已满，从双向链表尾部移除最久未使用的节点，并从哈希表中删除对应的键。
        • 然后，创建新节点，添加到双向链表的头部，并更新哈希表。
  1. 复杂度：时间复杂度O(1)，空间复杂度O(capacity)。
  2. c++ demo：
#include <iostream>
#include <unordered_map>
#include <list>

class LRUCache {
private:
    int capacity;
    std::list<int> items; // 双向链表，存储键
    std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射

    void moveToHead(int key) {
        items.splice(items.begin(), items, cache[key]); // 将节点移动到头部
    }

    void removeLeastRecent() {
        if (!items.empty()) {
            cache.erase(items.back()); // 从哈希表中删除
            items.pop_back(); // 从链表中删除
        }
    }

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        if (cache.find(key) != cache.end()) {
            moveToHead(key);
            return items.front();
        }
        else {
            return -1; // 键不存在
        }
    }

    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            items.erase(cache[key]); // 从链表中删除旧节点
            cache.erase(key);
        }
        if (items.size() >= capacity) {
            removeLeastRecent(); // 检查是否需要淘汰
        }
        items.push_front(key); // 添加新节点到头部
        cache[key] = items.begin(); // 更新哈希表
    }
};

int main() {
    LRUCache cache(2);

    cache.put(1, 1);
    std::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 1
    cache.put(2, 2);
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 2
    cache.put(3, 3); // 淘汰键 1 使用 put
    std::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 -1 (未找到)
    std::cout << "Get 3: " << cache.get(3) << std::endl; // 返回 3
    cache.put(4, 4); // 淘汰键 2 使用 put
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 -1 (未找到)
    cache.put(2, 6); // 重新添加键 2
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 6

    return 0;
}
  • 输出结果：

Get 1: 1
Get 2: 2
Get 1: -1
Get 3: 3
Get 2: -1
Get 2: 2

LRU 缓存

LRU（Least Recently Used）缓存是一种常用的缓存淘汰策略，它基于一个原则：如果数据最近被访问过，那么将来被访问的几率也更高。LRU 缓存通常用于操作系统、数据库、Web 服务器等场景，以减少内存或存储的使用，同时保持最常访问的数据可用。

LRU 缓存的实现

实现 LRU 缓存的一种常见方法是使用哈希表和双向链表。哈希表提供了 O(1) 的访问时间复杂度，而双向链表则允许我们以 O(1) 的时间复杂度进行数据的添加和删除操作。

数据结构
  1. 哈希表：存储键和对应节点的指针，以便快速访问。
  2. 双向链表：存储缓存中的项，最近使用的项在头部，最不常使用的项在尾部。
操作

  1. 访问缓存：

    • 检查键是否存在于哈希表中。
    • 如果存在，将对应的节点移动到双向链表的头部。
    • 如果不存在，根据需要从链表尾部移除一个节点（如果缓存已满），然后将新节点添加到头部。

  2. 添加到缓存：

    • 如果键已存在，更新其值，并将节点移动到链表头部。
    • 如果键不存在，创建新节点，添加到链表头部，并在哈希表中记录。

  3. 淘汰缓存：

    • 当缓存达到容量限制时，从链表尾部移除最不常使用的项，并从哈希表中删除相应的键。

示例代码

以下是使用 C++ 实现的 LRU 缓存的简单示例：

#include <iostream>
#include <list>
#include <unordered_map>

class LRUCache {
private:
    int capacity;
    std::list<int> items; // 双向链表，存储键
    std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射

    void moveToHead(int key) {
        items.splice(items.begin(), items, cache[key]); // 将节点移动到头部
    }

    void removeLeastRecent() {
        if (items.size() > capacity) {
            cache.erase(items.back()); // 从哈希表中删除
            items.pop_back(); // 从链表中删除
        }
    }

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        if (cache.find(key) != cache.end()) {
            moveToHead(key);
            return items.front();
        } else {
            return -1; // 键不存在
        }
    }

    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            items.erase(cache[key]); // 从链表中删除旧节点
        } else {
            removeLeastRecent(); // 检查是否需要淘汰
        }
        items.push_front(key); // 添加新节点到头部
        cache[key] = items.begin(); // 更新哈希表
    }
};

int main() {
    LRUCache cache(2);
    cache.put(1, 1);
    std::cout << cache.get(1) << std::endl; // 返回 1
    cache.put(2, 2);
    std::cout << cache.get(2) << std::endl; // 返回 2
    cache.put(3, 3); // 淘汰键 1
    std::cout << cache.get(1) << std::endl; // 返回 -1 (未找到)
    std::cout << cache.get(3) << std::endl; // 返回 3
    cache.put(4, 4); // 淘汰键 2
    std::cout << cache.get(2) << std::endl; // 返回 -1 (未找到)
    return 0;
}

这个示例展示了 LRU 缓存的基本操作，包括 get 和 put 方法。get 方法用于访问缓存中的项，而 put 方法用于添加或更新缓存中的项。如果缓存达到容量限制，put 方法还会淘汰最不常使用的项。

码流怪侠
关注
专栏目录
C++笔试题之LRU Cache原理和实现
草上爬的博客
12-12 2万+
C++笔试题之LRU Cache原理和实现 LeetCode上有着样一道题目： Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be pos
使用C++实现一个LRU cache
鱼思故渊的专栏
09-28 5048
什么是LRU Cache LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM，通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间，用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache
C++速通LeetCode中等第22题-LRU缓存
最新发布
lyx的博客
09-22 233
双向循环链表和哨兵节点的使用
LRU Cache数据结构简介
dltvtl1977的博客
11-25 277
什么是LRU Cache 　　LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU...
LRU Cache -- LeetCode
编程语言小筑
03-19 222
原题链接:http://oj.leetcode.com/problems/lru-cache/这是一道非常综合的题目，主要应用在操作系统的资源管理中。按照题目要求，要实现get和set功能，为了满足随机存储的需求我们首先想到的一般是用数组，如果用链表会有O(n)的访问时间。然而他又有另一个条件就是要维护least used的队列，也就是说经常用的放在前面，用的少的放在后面。这样当资源超过cache...
C++实现LRU Cache
qq_33457548的博客
08-02 493
1、算法思路： put操作思路： 用一个双向链表和一个哈希表； 每添加一个(key, value),先判断是否在哈希表中存在，如果存在，那么删除哈希表中的键值对和双向链表中的该元素； 再往双向链表头部增加添加的(key, value)和哈希表中增加(key,value); 最后判断是否超过capacity,若超过则弹出链表尾部元素和删除哈希表中该键值对。 优化： 哈希表中保存&lt...
Leetcode: LRU Cache
热门推荐
ZkvIA的博客
11-11 1万+
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be positive) of the key if
LeetCode练习：掌握LRU缓存算法
描述中的 "lru缓存leetcode 力码练习" 强调了这是一个编程实践的过程。标签 "系统开源" 表明了练习题是开放源代码的，可以在开源社区中找到和学习。而 "leetcode-master" 则可能是包含了练习题目的压缩包文件名称，...
LeetCode算法解决方案：LRU缓存与各类编程问题技巧
LRU缓存算法是计算机科学中的一个经典问题，它解决的是如何在有限的存储空间内高效地存储和访问数据。LRU代表“最近最少使用”（Least Recently Used），其核心思想是优先淘汰最长时间未被使用的数据。在处理高并发...
LeetCode题解：使用Python/Go/C++实现LRU缓存算法
在LeetCode等编程题目中，通常会要求实现LRU缓存的算法，如设计一个数据结构支持get和put操作，其中put操作会覆盖最久未使用的数据。 4. 排序算法：项目提到了多种排序算法，包括冒泡排序、希尔排序、快速排序、...
LeetCode高效解决方案集锦：LRU缓存等算法实践
在这个代码库中，开发者可以找到解决LeetCode中LRU缓存相关问题的源代码，可能包括实现LRU缓存算法的各类编程语言的代码，如Python、Java、C++等。 这些资源对于解决数据结构与算法相关问题的程序员来说，是非常...
LRU Cache的简单C++实现
01-20
什么是 LRU 　　LRU Cache是一个Cache的置换算法，含义是“近少使用”，把满足“近少使用”的数据从Cache中剔除出去，并且保证Cache中第一个数据是近刚刚访问的，因为这样的数据更有可能被接下来的程序所访问。 　　LRU的应用比较广泛，基础的内存页置换中用了，对了，这里有个概念要清楚一下，Cache不见得是CPU的高速缓存的那个Cache，这里的Cache直接翻译为缓存，是两种存储方式的速度有比较大的差别，都可以用Cache缓存数据，比如硬盘明显比内存慢，所以常用的数据我们可以Cache在内存中。 　　LRU 基本算法描述 　　前提： 　　由于我只是简单实现一下这个算
C++实现LeetCode问题的LRU缓存算法解决方案
从文件描述中可以得知，该资源包含了多个LeetCode算法题目的解决方案，涵盖了从简单到困难不同难度级别的问题。项目中还包含了每个解决方案的标题、难度级别、通过测试结果和完成时间等信息。以下是从文件描述中提取...
【LeetCode】LRU缓存（C++代码）
qq_42887507的博客
04-26 2127
题目 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导
LeetCode146. LRU缓存(C++)
Xavier_97的博客
03-10 772
本来是可以用单链表就解决问题的，但是STL提供的forward_list并没有暴露其指针的接口，这就导致了我们无法移动元素，而只能先删除元素再进行插入来替代移动元素，同时forward_list不支持删除当前迭代器指向的元素，只支持删除当前迭代器之后的元素，所以这里最终采用双链表来完成。不太优雅的解法，因为没用STL提供的Hashmap，所以这里手动创建一个Hashmap类来模拟哈希表，因此占用空间比较多。题目设计缓存的容量最大就是10001，因此就开一个这么大的数组用于模拟哈希表。
LeetCode第 146 题：LRU缓存机制(C++)
zj
07-20 1135
146. LRU缓存机制 - 力扣（LeetCode） LRU需要注意： 1、访问了某个元素之后，就要把这个元素的位置放到缓存的头部（最近使用） 2、向缓存写入数据是，先检查该数据是否存在，如果不存在，则在头部写入，否则就将存在的值移动到头部（因为也算是进行了访问），题目还要求了对存在的值进行修改 3、缓存满了之后，从缓存的尾部（最久没使用）开始删除元素以腾出空间 第一条，需要移除该元素，并将该元素放到头部，也就是快速的删除和添加，删除的元素可能在任何位置。那就最好使用链表了，链表删除/添加元素的复杂度
C++实现LRU cache
线上幽灵
10-25 422
C++实现LRU cache
C++ LRU cache 实现
无人等人的博客
09-08 722
LRU 实现
LRU 算法实现
Algebra2016的博客
10-29 299
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be positive) of the key if
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码流怪侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值