LRU缓存机制(lru-cache)采用java版双向链表 + Map实现

最新推荐文章于 2024-08-09 23:16:53 发布
最新推荐文章于 2024-08-09 23:16:53 发布
阅读量1.4k 收藏 2
点赞数 2
分类专栏： # acm # 零基础学数据结构 文章标签： java 缓存 链表 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e891377/article/details/105122711
版权

文章目录

LRU缓存机制(lru-cache)

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

java模板

需要实现构造函数，get方法，put方法。

class LRUCache {

    public LRUCache(int capacity) {

    }
    
    public int get(int key) {

    }
    
    public void put(int key, int value) {

    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

实现

  • 由于题目的时间复杂度要求 O(1)O(1)，空间肯定不能省，存取数据时间性能最好的就是哈希表，因此底层的数据结构一定是一个哈希表；
  • 根据题目意思，访问某个数据，时间优先级得提前，还有删除末尾结点的需求，这样的数据结构得在头尾访问数据最快，这种数据结构是「双向链表」；
  • 「链表」结点需要记录：1、value，2、key（在哈希表里删除的时候用得上），3、前驱结点引用，4、后继结点引用。

思路来自liweiwei1419大神，感谢。

操作图

在这里插入图片描述

内部结构图

在这里插入图片描述

  • 新数据插入到链表头部
  • 每当缓存命中（即缓存数据被访问），则将数据移到链表头部
  • 当链表满的时候，将链表尾部的数据丢弃

LRU Cache具备的操作：

  • put(key,value)：如果key在hashmap中存在，则先重置对应的value值，然后获取对应的节点cur，将cur节点从链表删除，并移动到链表的头部；若果key在hashmap不存在，则新建一个节点，并将节点放到链表的头部。当Cache存满的时候，将链表最后一个节点删除即可。
  • get(key)：如果key在hashmap中存在，则把对应的节点放到链表头部，并返回对应的value值；如果不存在，则返回-1。

伪代码模板与思路

package lfu_cache;

import java.util.HashMap;
import java.util.Map;

/**
 * https://www.bilibili.com/video/BV1sb411v7Pt
 */
public class LFUCache3 {

  class DLinkedNode {
    int key;//思考,这里为什么要一个key
    int value;
    DLinkedNode prev;
    DLinkedNode next;
  }

  //核心方法--必记
  private void addNode(DLinkedNode node) {
    //始终在head之后添加新节点
    //一共四步
    //先处理上层连接，---> node --->
    //再处理下层连接，<--- node <---
  }

  //核心方法--必记
  private void removeNode(DLinkedNode node){
	  //从链接列表中删除现有节点
	  //也是四步
	  //拿到node的前驱与后驱，再连接就可以了
  }

  //将节点移动到头部
  private void moveToHead(DLinkedNode node){
    //将中间的某个节点移到头部
    //先移除节点，再加到前面，用上面两个核心方法就可以实现这个方法
  }

  //从链表中删除节点，超出容量时用到该方法
  private DLinkedNode popTail() {
    //通过虚拟的尾节点的前驱节点返回真正的尾节点，然后在链表中删除它
    //还要刻返回给哈希表，让哈希表也进行一下移除操作
    return res;
  }

  //==============================四个变量
  //哈希表，提供o(1)的获取。
  private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
  private int size;//当前数量
  private int capacity;//容量
  //双向链表，虚拟头结点，虚拟尾结点(没有尾结节，删除最后一个元素太慢，要的)
  private DLinkedNode head, tail;//双端链表头，尾
  //==============================

  public LFUCache3(int capacity) {//初始化
    this.size = 0;
    this.capacity = capacity;

	//虚拟头结点没有前驱
    head = new DLinkedNode();//有点像一前一后两个哨兵
    // head.prev = null;

	//虚拟尾结点没有后继
    tail = new DLinkedNode();
    // tail.next = null;

    head.next = tail;
    tail.prev = head;
  }

  //获取数据
  public int get(int key) {
    DLinkedNode node = cache.get(key);
    if (node == null) return -1;

    // 将访问的节点移动到头部
    ...

    return node.value;
  }

  //数据放进去
  //比较难，
  //先判断非空，空，hash添加元素，双端链表添加元素，再判断是否超容，
  //---------------超容了，获取链表尾的元素，移除，数量减减
  //非空，更新值，并移动到头部。
  public void put(int key, int value) {
    DLinkedNode node = cache.get(key);

    if(node == null) {//为空，肯定是哈希表和双向链表都操作一下
    	...

      if(size > capacity) {//超容，肯定是哈希表和双向链表都操作一下
        // pop the tail
    	  ...
      }
    } else {//非空，说明有节点存在，肯定是哈希表和双向链表都操作一下
      // update the value.
    	...
    }
  }


}

具体代码

import java.util.Hashtable;
public class LRUCache {

  class DLinkedNode {
    int key;//思考,这里为什么要一个key
    int value;
    DLinkedNode prev;
    DLinkedNode next;
  }

  private void addNode(DLinkedNode node) {
    /**
     * Always add the new node right after head.
     */
    node.prev = head;
    node.next = head.next;

    head.next.prev = node;
    head.next = node;
  }

  private void removeNode(DLinkedNode node){
    /**
     * Remove an existing node from the linked list.
     */
    DLinkedNode prev = node.prev;
    DLinkedNode next = node.next;

    prev.next = next;
    next.prev = prev;
  }

  private void moveToHead(DLinkedNode node){
    /**
     * Move certain node in between to the head.
     */
    removeNode(node);
    addNode(node);
  }

  private DLinkedNode popTail() {
    /**
     * Pop the current tail.
     */
    DLinkedNode res = tail.prev;
    removeNode(res);
    return res;
  }

  private Hashtable<Integer, DLinkedNode> cache =
          new Hashtable<Integer, DLinkedNode>();
  private int size;
  private int capacity;
  private DLinkedNode head, tail;

  public LRUCache(int capacity) {
    this.size = 0;
    this.capacity = capacity;

    head = new DLinkedNode();
    // head.prev = null;

    tail = new DLinkedNode();
    // tail.next = null;

    head.next = tail;
    tail.prev = head;
  }

  public int get(int key) {
    DLinkedNode node = cache.get(key);
    if (node == null) return -1;

    // move the accessed node to the head;
    moveToHead(node);

    return node.value;
  }

  public void put(int key, int value) {
    DLinkedNode node = cache.get(key);

    if(node == null) {
      DLinkedNode newNode = new DLinkedNode();
      newNode.key = key;
      newNode.value = value;

      cache.put(key, newNode);
      addNode(newNode);

      ++size;

      if(size > capacity) {
        // pop the tail
        DLinkedNode tail = popTail();
        cache.remove(tail.key);
        --size;
      }
    } else {
      // update the value.
      node.value = value;
      moveToHead(node);
    }
  }
}

/**
 * LRUCache 对象会以如下语句构造和调用:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

如果要背这道题去面试，记住addNode方法，removeNode方法就行了。
注意了，这里的链表头尾是不存数据的，所以put操作是添加到头结节后面，超出容量执行remove操作是移除链表尾结点的前一个。

小总结

LRU缓存机制，是一个哈希表+双向链表的实现，不管是获取节点，还是把节点放进LRU缓存，均须考虑对哈希表和双向链表的操作。

参考资料

LRU缓存机制(lru-cache)
LRU和LFU的区别
146. LRU缓存机制
liweiwei1419大神

怪我冷i
关注
专栏目录
LRU 缓存机制实现：哈希表 + 双向链表
程序员光剑
03-21 8779
算法详解LRU 缓存机制可以通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。哈希表即为普通的哈希映射(HashMap)，通过缓存数据的键映射到其在双向链表中的位置。这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头...
【leetcode】146.LRU缓存机制 （哈希表+双向链表，java实现）
Viper的程序员修炼手册
08-21 517
146. LRU缓存机制 难度中等 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空
node-lru-cache
03-31
lru缓存 删除最近使用最少的项目的缓存对象。 安装： npm install lru - cache -- save 用法： var LRU = require ( "lru-cache" ) , options = { max : 500 , length : function ( n , key ) { return n * 2 + key . length } , dispose : function ( key , n ) { n . close ( ) } , maxAge : 1000 * 60 * 60 } , cache = new LRU ( options ) , otherCache = new LRU ( 50 ) // sets just the max size
10行Java代码实现最近被使用（LRU）缓存
N/A
07-16 668
在最近的面试中，我曾被多次问到，怎么实现一个最近最少使用（LRU）的缓存。缓存可以通过哈希表来实现，然而为这个缓存增加大小限制会变成另一个有意思的问题。现在我们看一下怎么实现。 最近最少使用缓存的回收 为了实现缓存回收，我们需要很容易做到： 查询出最近最晚使用的项给最近使用的项做一个标记 链表可以实现这两个操作。检测最近最少使用的项只需要返回链表的尾部。标记一项为最近使用的
高阶数据结构——LRU Cache
最新发布
weixin_74310945的博客
08-09 804
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
146.LRU缓存机制
高一少年的博客
05-13 211
146.LRU缓存机制 文章目录题目分析Solution 题目分析 LRU是操作系统常用的一种页面置换算法,选择最近最久未使用的页面予以淘汰 虚拟头尾节点 哈希表+双向链表 Solution public class LRUCache { private Map<Integer, Node> map; private int capacity; // 虚拟头结点 private Node first; // 虚拟尾结点 private Nod
LeetCode-146. LRU Cache（双向链表 + 哈希表）
保持对编程的热情！
08-24 187
146.LRU Cache Medium 3402127FavoriteShare Design and implement a data structure forLeast Recently Used (LRU) cache. It should support the following operations:getandput. get(key)- Get the va...
双向链表实现的简易缓存(LRU Cache)
嘻嘻哈哈在成长
08-29 1289
问题： 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 th
lru-cache：C ++中功能完整的LRU缓存实现
02-05
在C++中，LRU缓存通常通过结合哈希表（如`std::unordered_map`）和双向链表（如`std::list`或自定义实现）来实现。哈希表用于快速查找，而双向链表则用于保持数据的访问顺序。当一个元素被访问时，它会在链表中移动...
java之双向链表与哈希表实现LRU缓存机制
一名正在成长的程序员
10-27 721
背景 在研究双向队列之前，是遇到了这么一道题。 146. LRU缓存机制 这道题的思路是HashMap与双向队列的组合。LRU就是删除最近最少使用的数据值。 比如我先打开了支付宝，之后打开了手机淘宝，之后打开微信，此时在后台就是如下排列 之后我又点击支付宝，在后台中就会来到队友 假如缓存容量为3的话，此时又打开了时钟，就会把淘宝从缓存中删除，因为他是最近最少使用的应用。 那么这道题的思路很清...
LRU缓存实现(Java)
guanshengg的博客
08-25 594
LRU是Least Recently Used 的缩写，翻译过来就是“最近最少使用”，LRU缓存就是使用这种原理实现，简单的说就是缓存一定量的数据，当超过设定的阈值时就把一些过期的数据删除掉，比如我们缓存10000条数据，当数据小于10000时可以随意添加，当超过10000时就需要把新的数据添加进来，同时要把过期数据删除，以确保我们最大缓存10000条，那怎么确定删除哪条过期数据呢，采用LRU算法实现的话就是将最老的数据删掉，废话不多说，下面来说下Java版的LRU缓存实现。
node-lru:nodejs实现的lru缓存
07-10
Node LRU Cache 基于Nodejs开发的LRU Cache, 兼有缓存超时清除功能 usage var options = { expires: 5 * 60 * 1000, capacity: 5 }; var LRU = require('node-lru'); var cache = new LRU(2);//var cache = new LRU(options); cache.set('key1', 'value1'); cache.set('key2', 'value2'); cache.set('key3', 'value3'); var value = cache.get('key2'); cache.on('extrusion', function (tail) { console.log(tail.key + ": " + tail.value)
LRU-Cache:通过Node.js实现LRU缓存
05-09
LRU缓存 Node.js中的LRU缓存实现 用法 const lru = require ( 'LRU-Cache' ) ; 。放 capacity -列表容量，不允许0，默认值：1000 maxAge节点将在maxAge ms内自行销毁 const cache = new lru ( { capacity : 100 } ) ; cache . set ( 'test_key' , 123 ) ; cache . set ( 'test_key' , 234 ) ; console . info ( cache . toArray ( 'test_key' ) . length ) ; > 2 具有maxAge的实例lru /* the node will be destroyed in 1000 ms one by one */ const cache = new lru (
lru-cache-node:具有最近使用策略的节点的照明快速缓存管理器
04-25
lru-cache-node 具有最近使用策略的节点的照明快速缓存管理器。 具有LRU策略的节点的超快速缓存。 缓存将继续添加值，直到达到maxSize为止。 之后，它将开始从缓存中弹出最近最少使用/访问的值，以便设置新值。 支持到期和过期。 使用双向链表和哈希图实现，获取和设置的时间复杂度为O（1）。 安装 $ npm install --save lru-cache-node 用法 const Cache = require ( 'lru-cache-node' ) ; let cache = new Cache ( 3 ) ; //set max size of cache as three cache . set ( 'a' , 7 ) ; //sets a value in cache with 'a' as key and 7 as value cache . set
146. LRU Cache (双向链表+哈希表实现 LRU Cache)
Elo的博客
11-07 385
146. LRU Cache 题目大意: 设计并实现一个 LRU Cache. 实现对应的函数 get(key), put(key, value). Follow up: 所有操作 O(1) 时间复杂度. 实现 LRU Cache 的关键数据结构: 双向链表 + 哈希表. 以下实现中, 定义了双向链表结点类 Node. 以及 unordered_map<int, *Node> 类型的 ...
LRU缓存机制
沐雨金鳞
06-30 336
运用你所掌握的数据结构，设计和实现一个LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据get和 写入数据put。 获取数据get(key)- 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。 写入数据put(key, value)- 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 进阶: 你是否可以在...
lru-cache
ailinyingai的博客
12-06 219
class Node(object): def __init__(self, results): self.results = results self.next = next class LinkedList(object): def __init__(self): self.head = None self...
【算法】【LRU】146. LRU缓存机制
wurlin的博客
04-17 3522
Description 设计和实现一个LRU（最近最少使用）缓存数据结构，使它应该支持以下操作： get 和 put 。 get(key) - 如果密钥存在于缓存中，则获取密钥的值（值总是正数），否则返回 -1。 put(key, value) - 如果密钥不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项目作废。 后续: 你是否可以在 O(1) 时间复...
Java实现LRU缓存机制详解及代码示例
"Java 实现简单 LRU 缓存机制的方法" ...总结来说，Java 中实现 LRU 缓存机制的关键在于结合哈希表和双向链表，利用哈希表快速定位，链表记录访问顺序。通过以上步骤，我们可以构建一个符合 LRU 策略的高效缓存系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值