如何设计一个LRU Cache

最新推荐文章于 2024-08-09 23:16:53 发布
转载 最新推荐文章于 2024-08-09 23:16:53 发布 · 657 阅读 · 0
文章标签：

#cache #hashmap #数据结构 #powerbuilder #存储 #system

本文详细介绍了如何设计一个LRUCache，利用双向链表和哈希表实现高效的数据存储与管理。通过优化数据结构，确保查找、插入、删除操作在O(1)时间内完成，满足缓存系统的基本需求。

From: http://blog.youkuaiyun.com/hexinuaa/article/details/6630384

如何设计一个LRU Cache？

通常的问题描述可以是这样：

Question：
[1] Design a layer in front of a system which cache the last n requests and the responses to them from the system.
在一个系统之上设计一个Cache，缓存最近的n个请求以及系统的响应。
what data structure would you use to implement the cache in the later to support following operations.
用什么样的数据结构设计这个Cache才能满足下面的操作呢？
[a] When a request comes look it up in the cache and if it hits then return the response from here and do not pass the request to the system
[b] If the request is not found in the cache then pass it on to the system
[c] Since cache can only store the last n requests, Insert the n+1th request in the cache and delete one of the older requests from the cache
因为Cache只缓存最新的n个请求，向Cache插入第n+1个请求时，从Cache中删除最旧的请求。
[d]Design one cache such that all operations can be done in O(1) – lookup, delete and insert.

Cache简介：
Cache(高速缓存)， 一个在计算机中几乎随时接触的概念。CPU中Cache能极大提高存取数据和指令的时间，让整个存储器(Cache+内存)既有Cache的高速度，又能有内存的大容量；操作系统中的内存page中使用的Cache能使得频繁读取的内存磁盘文件较少的被置换出内存，从而提高访问速度；数据库中数据查询也用到Cache来提高效率；即便是Powerbuilder的DataWindow数据处理也用到了Cache的类似设计。Cache的算法设计常见的有FIFO(first in first out)和LRU(least recently used)。根据题目的要求，显然是要设计一个LRU的Cache。


解题思路：
Cache中的存储空间往往是有限的，当Cache中的存储块被用完，而需要把新的数据Load进Cache的时候，我们就需要设计一种良好的算法来完成数据块的替换。LRU的思想是基于“最近用到的数据被重用的概率比较早用到的大的多”这个设计规则来实现的。
为了能够快速删除最久没有访问的数据项和插入最新的数据项，我们双向链表连接Cache中的数据项，并且保证链表维持数据项从最近访问到最旧访问的顺序。每次数据项被查询到时，都将此数据项移动到链表头部（O(1)的时间复杂度）。这样，在进行过多次查找操作后，最近被使用过的内容就向链表的头移动，而没有被使用的内容就向链表的后面移动。当需要替换时，链表最后的位置就是最近最少被使用的数据项，我们只需要将最新的数据项放在链表头部，当Cache满时，淘汰链表最后的位置就是了。

注： 对于双向链表的使用，基于两个考虑。首先是Cache中块的命中可能是随机的，和Load进来的顺序无关。其次，双向链表插入、删除很快，可以灵活的调整相互间的次序，时间复杂度为O(1)。

查找一个链表中元素的时间复杂度是O(n)，每次命中的时候，我们就需要花费O(n)的时间来进行查找，如果不添加其他的数据结构，这个就是我们能实现的最高效率了。目前看来，整个算法的瓶颈就是在查找这里了，怎么样才能提高查找的效率呢？Hash表，对，就是它，数据结构中之所以有它，就是因为它的查找时间复杂度是O(1)。
梳理一下思路：对于Cache的每个数据块，我们设计一个数据结构来储存Cache块的内容，并实现一个双向链表，其中属性next和prev时双向链表的两个指针，key用于存储对象的键值，value用户存储要cache块对象本身。

Cache的接口：
查询：
根据键值查询hashmap，若命中，则返回节点，否则返回null。
从双向链表中删除命中的节点，将其重新插入到表头。
所有操作的复杂度均为O(1)。
插入：
将新的节点关联到Hashmap
如果Cache满了，删除双向链表的尾节点，同时删除Hashmap对应的记录
将新的节点插入到双向链表中头部
更新：
和查询相似
删除：
从双向链表和Hashmap中同时删除对应的记录。

如何设计一个LRU Cache？
07-24 2万+
如何设计一个LRU Cache？Google和百度的面试题都出现了设计一个Cache的题目，什么是Cache，如何设计简单的Cache，通过搜集资料，本文给出个总结。 通常的问题描述可以是这样：Question：[1] Design a layer in front of a s
设计LRU缓存结构
STAR
03-07 972
1、题目描述 链接：https://www.nowcoder.com/questionTerminal/e3769a5f49894d49b871c09cadd13a61 来源：牛客网 设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 [要求] set和get方法的时间复杂度为O(1) 某个key的set或get操作一旦发生，认为这个key的记录成了最
2022/8/16——基于IO多路复用的TCP客户端
ad20001218的博客
08-16 406
基于IO多路复用的TCP客户端
设计并实现一个LRU Cache
dbbaq24022的专栏
05-09 342
一、什么是Cache 1 概念 Cache，即高速缓存，是介于CPU和内存之间的高速小容量存储器。在金字塔式存储体系中它位于自顶向下的第二层，仅次于CPU寄存器。其容量远小于内存，但速度却可以接近CPU的频率。 当CPU发出内存访问请求时，会先查看 Cache 内是否有请求数据。 如果存在（命中），则直接返回该数据； 如果不存在（失效），再去访问内存 —...
设计实现一个LRU Cache
weixin_33860553的博客
04-13 712
1 什么是LRU Cache 在LeetCode上有一个LRU Cache实现的题目 Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following oper...
Python实现的一个简单LRU cache
12-25
这里我们将讨论如何使用Python实现一个简单的LRU缓存。 首先，我们要明确LRU缓存的主要特性： 1. **键值对存储**：LRU缓存需要存储键（key）和对应的值（value），通常使用字典（dictionary）来实现键值对的快速...
javalruleetcode-LRU_cache:LRU_cache
06-29
LRU_cache (Leetcode 146) 设计和实现最近最少使用 (LRU) 缓存的数据结构。 它应该支持以下操作：get 和 set。 get(key) – 如果键存在于缓存中，则获取键的值（将始终为正），否则返回 -1。 set(key, value) – ...
高阶数据结构——LRU Cache
weixin_74310945的博客
08-09 1704
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
【数据结构】LRU Cache
The porters of knowledge
02-15 689
使用链表和哈希表来实现高效的LRUCache数据结构
Cache的设计和实现 LRU Cache
LUCKYOJ
03-31 2812
Cache的应用非常广泛，其实Cache是一种思想，一个广义的词汇，一种在性能和金钱的权衡上的思想。 Cache的思想用在很多地方，使用的载体也不同，都是位于相对高速设备和相对低速设备之间，起到缓存的作用。 1、最常用处：用在内存和CPU之间，以SRAM作为Cache的载体。（内存是DRAM，CPU是寄存器） 2、用在内存和硬盘之间。 3、用在硬盘和网络之间。
设计一个LRU Cache
SG的专栏
03-08 724
原来遇到的一个面试题，今天意外想起，记录一下。问题：设计实现一个LRU Cache，需要支持三种操作：插入(insert)、替换(replace)、查找（lookup）思路：用HashMap做为基础容器，容器内Value组成双向链表，由双向链表支持LRU的替换策略。链表需要维持数据项从最近访问到最旧访问的顺序。插入：当Cache未满时，新的数据项只需插到双链表头部即可。时间复杂度为O(1)O(1)...
设计一个Cache系统 【双向链表+哈希表】
u010585135的专栏
03-21 818
转自：http://blog.youkuaiyun.com/yangcs2009/article/details/38351573 今天去面试，面试官让我设计一个cache系统，要求保证最近使用的数据不能被移除出cache,也就是每次添加一个cache项的时候，把最旧的cache项移除出去。     我只记得操作系统里貌似有个差不多的cache算法，记不起名字来，更别提数据结构了。一开始我执着
LRU缓存设计
LJJZJ的博客
09-18 241
设计一个LRU算法（最近最少移除）来实现缓存 思路： 使用双向链表 + HashMap 实现 采取尾插法，未达到存储上限就每次在加入到链表尾部 访问链表节点，就将对应链表节点移到尾部，保持尾节点数据最新 链表长度达到上限就删除头节点 代码： public class LRUCache { private Node head; private Node end; //...
实现一个LRU 算法
chenxing3355的博客
06-30 228
lru 这种算法一般用于缓存过期策略，这里用一个hashmap和node这两种数据结构实现，代码如下 import java.util.HashMap; import java.util.Map; public class LRU { private Node head;/...
设计LRU缓存结构（Java实现）
renxingzhadan的专栏
06-28 455
（1）是什么？ Least Recently Used （最近最少使用） 缓存淘汰算法中的一种。因为缓存是保存在内存中的，内存是很吃紧很宝贵的，所以要保证最热点的数据做缓存，冷门数据淘汰。 （2）具体在哪些场景使用？ Mysql的缓冲池，Linux OS 的虚拟文件系统VFS都有用到。 （3）具体实现步骤？ 既然是缓存，那肯定就是List中存放着一大串 Key - Value 结构，我们查找目标数据的时候就是for这个List找到对应的Key，这个List可能很长，所以我们可以把热点数据排到较前面，冷门
实现LRU缓存
qq_43568109的博客
06-06 493
题目描述 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) ： 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key)： 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value)： 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写
设计LRU缓存结构算法
m0_49961610的博客
11-29 592
LRU缓存结构
设计一个LRU类
最新发布
03-28
### 设计与实现LRU缓存类 #### 背景介绍 LRU（Least Recently Used）是一种常见的缓存淘汰策略，用于管理固定大小的缓存空间。当缓存满时，会优先移除最近最少使用的数据项[^3]。 #### 数据结构的选择 为了高效地实现LRU缓存，通常采用哈希表（Hash Map）和双向链表（Doubly Linked List）相结合的方式： - **哈希表**：提供O(1)时间复杂度的查找功能，存储键值对以及节点引用。 - **双向链表**：维护访问顺序，新访问的节点会被移动到头部，而尾部则是最久未访问的节点。 这种组合能够确保`get`和`put`操作的时间复杂度均为O(1)[^4]。 --- #### Python实现 以下是基于Python的LRU缓存类实现： ```python class DLinkedNode: def __init__(self, key=0, value=0): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity: int): self.cache = {} self.capacity = capacity self.size = 0 self.head = DLinkedNode() self.tail = DLinkedNode() # 初始化头尾指针 self.head.next = self.tail self.tail.prev = self.head def _add_node(self, node: DLinkedNode): """始终将新的node添加到head之后""" node.prev = self.head node.next = self.head.next self.head.next.prev = node self.head.next = node def _remove_node(self, node: DLinkedNode): """删除指定节点""" prev = node.prev new_next = node.next prev.next = new_next new_next.prev = prev def _move_to_head(self, node: DLinkedNode): """将某个已存在的节点移到头部""" self._remove_node(node) self._add_node(node) def _pop_tail(self): """弹出tail前的一个节点""" res = self.tail.prev self._remove_node(res) return res def get(self, key: int) -> int: node = self.cache.get(key, None) if not node: return -1 self._move_to_head(node) return node.value def put(self, key: int, value: int): node = self.cache.get(key, None) if not node: new_node = DLinkedNode(key, value) self.cache[key] = new_node self._add_node(new_node) self.size += 1 if self.size > self.capacity: tail = self._pop_tail() del self.cache[tail.key] self.size -= 1 else: node.value = value self._move_to_head(node) ``` 上述代码实现了LRU缓存的核心逻辑，包括`get`方法、`put`方法以及辅助函数如 `_add_node`, `_remove_node`, 和 `_move_to_head` 等[^4]。 --- #### Java实现 以下是基于Java的LRU缓存类实现： ```java import java.util.HashMap; import java.util.Map; class Node { public int key, val; public Node next, prev; public Node(int k, int v){ this.key = k; this.val = v; } } public class LRUCache { private Map<Integer, Node> map = new HashMap<>(); private final int capacity; private int size; private Node head, tail; public LRUCache(int capacity) { this.capacity = capacity; this.size = 0; head = new Node(-1, -1); tail = new Node(-1, -1); head.next = tail; tail.prev = head; } private void add(Node node){ node.next = head.next; node.prev = head; head.next.prev = node; head.next = node; } private void remove(Node node){ node.prev.next = node.next; node.next.prev = node.prev; } private void moveToHead(Node node){ remove(node); add(node); } private Node popTail(){ Node res = tail.prev; remove(res); return res; } public int get(int key){ Node node = map.get(key); if(node == null) return -1; moveToHead(node); return node.val; } public void put(int key, int value){ Node node = map.get(key); if(node == null){ Node newNode = new Node(key, value); map.put(key, newNode); add(newNode); size++; if(size > capacity){ Node tail = popTail(); map.remove(tail.key); size--; } }else{ node.val = value; moveToHead(node); } } } ``` 此版本同样利用了哈希表和双向链表来实现高效的缓存管理和更新操作。 --- #### C++实现 以下是基于C++的LRU缓存类实现： ```cpp #include <unordered_map> using namespace std; struct ListNode { int key, value; ListNode* prev; ListNode* next; ListNode() : key(0), value(0), prev(nullptr), next(nullptr) {}; ListNode(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {}; }; class LRUCache { private: unordered_map<int, ListNode*> cache; int cap, size; ListNode *head, *tail; void addToHead(ListNode* node){ node->next = head->next; node->prev = head; head->next->prev = node; head->next = node; } void removeFromList(ListNode* node){ node->prev->next = node->next; node->next->prev = node->prev; } void moveToHead(ListNode* node){ removeFromList(node); addToHead(node); } ListNode* removeTail(){ ListNode* res = tail->prev; removeFromList(res); return res; } public: LRUCache(int capacity) { cap = capacity; size = 0; head = new ListNode(); tail = new ListNode(); head->next = tail; tail->prev = head; } int get(int key) { if(!cache.count(key)) return -1; ListNode* node = cache[key]; moveToHead(node); return node->value; } void put(int key, int value) { if(cache.count(key)){ cache[key]->value = value; moveToHead(cache[key]); } else{ ListNode* node = new ListNode(key, value); cache[key] = node; addToHead(node); ++size; if(size > cap){ ListNode* removed = removeTail(); cache.erase(removed->key); delete removed; --size; } } } }; ``` 这段代码展示了如何在C++中通过自定义链表节点和标准模板库中的`unordered_map`来构建LRU缓存。 --- #### 总结 以上分别提供了Python、Java和C++三种语言下的LRU缓存实现方案。每种实现均采用了相同的底层原理——即结合哈希表和双向链表完成快速定位与动态调整的功能需求。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值