面试题 16.25. LRU 缓存

最新推荐文章于 2022-04-07 20:31:19 发布
最新推荐文章于 2022-04-07 20:31:19 发布
阅读量154 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40422192/article/details/123161067
版权

LRU缓存 HashMap 双向链表 缓存淘汰 Java实现
关键词由CSDN通过智能技术生成

面试题 16.25. LRU 缓存

设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。

它应该支持以下操作： 获取数据 get 和 写入数据 put 。

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

示例:

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

方法一：

  • 创建一个Map -map保存 <key,val>
  • 创建一个Map-time保存 <key,time>
  • get(key)时
    • 如果存在，更新time(key,0),其余的key对应的time-1
    • 如果不存在，返回-1
  • put(key,val)时
    • 未未满时
      • 是否存在
        • 如果存在，更新(key,val),更新time(key,0),其余的key对应的time-1
        • 如果不存在, 添加map(key,val),添加time(key,0)，其余的key对应的time-1;
    • 满时
      • 是否存在
        • 如果存在，更新(key,val),更新time(key,0)，其余的key对应的time-1
        • 如果不存在，删除time中最小的val，删除map对应的key，添加map(key,val),添加time(key,0)，其余的key对应的time-1;

​

package 力扣;

import java.util.HashMap;
// 实现了但是超时
public class LRUCache {
    public static void main(String[] args) {
        LRUCache lruCache=new LRUCache(2);
        System.out.println(lruCache.get(2));
        lruCache.put(2,6);
        System.out.println(lruCache.get(1));
        lruCache.put(1,5);
        lruCache.put(1,2);
        System.out.println(lruCache.get(1));
        System.out.println(lruCache.get(2));
    }

    HashMap<Integer,Integer> map=new HashMap<>();
    HashMap<Integer,Integer> time=new HashMap<>();
    int capacity;
    int usedCapacity;

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





    public int get(int key) {
        if (map.containsKey(key)) {
            // 更新值
            changeTime(key);
            return map.get(key);
        }
        return -1;
    }

    public void changeTime(Integer key){
        // 更新值
        if(time.isEmpty()){
            time.put(key,0);
        }else {
            for (Integer integer : time.keySet()) {
                time.put(integer,time.get(integer)-1);
            }
            time.put(key,0);
        }
    }

    public Integer getLRU(){
        int min=1;
        int key=0;
        for (Integer integer : time.keySet()) {
           if(time.get(integer)<min){
               min=time.get(integer);
               key=integer;
           }
        }
        return key;
    }

    public void put(int key, int value) {
        // 情况一 容量尚未占满
        if(usedCapacity<capacity){
            if(map.containsKey(key)){
                map.put(key,value);
                // 更新值
                changeTime(key);
            }else {
                map.put(key,value);
                usedCapacity++;
                // 更新值
                changeTime(key);
            }
        }else {
            // 情况二 容量已经被占满 需要删除一个最近未使用的
            if(usedCapacity==capacity){
                if(map.containsKey(key)){
                    map.put(key,value);
                    // 更新值
                    changeTime(key);
                }else{
                    Integer lruKey = getLRU();
                    map.remove(lruKey);
                    time.remove(lruKey);
                    map.put(key,value);
                    //更新值
                    changeTime(key);
                }


            }
        }

    }
}

方法二：

  • 使用双向链表
    • Node {int key,int val,Node pre，Node next}

在这里插入图片描述

package 力扣;

// 上一个方法太笨了の 这里使用最基础的双向链表实现

import javax.sound.midi.Soundbank;
import java.time.temporal.ValueRange;

public class LRUCache2 {
    public static void main(String[] args) {
        LRUCache2 cache = new LRUCache2( 2 /* 缓存容量 */ );

        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1));
        cache.put(3, 3);    // 该操作会使得密钥 2 作废
        System.out.println(cache.get(2));
        cache.put(4, 4);    // 该操作会使得密钥 1 作废
        System.out.println(cache.get(1));
        System.out.println(cache.get(3));
        System.out.println(cache.get(4));


    }
    LinkList link;
    Integer capacity;
    Integer usedCapacity;

    public LRUCache2(Integer capacity) {
        this.capacity = capacity;
        usedCapacity=0;
        link=new LinkList();

    }
    public int get(int key) {
        // 获取这个数的值 ，先删除它，在添加他，这样他就在首位，删除时他是不是最后一个
       return link.getVal(key);
    }


    public void put(int key, int value) {

        //容量未满
        if(usedCapacity<capacity){
            // 更新数值或者添加
            link.NoFullADD(key,value);
            usedCapacity++;
        }
        //容量满了
        else {
            // 容量满了的条件下，更新数值或者添加
            link.FullADD(key,value);
        }


    }
}

class LinkList{
    Node head;
    Node end;

    public LinkList() {
        head=new Node();
    }
    public void bl(){
        Node p=head.next;
        System.out.print("当前链表:");
        while (p!=null){
            System.out.print("key:"+p.key+"-value:"+ p.val+",");
        }
        System.out.println();
    }

    public void add(int key,int val){
        if(head.next==null){
            Node p=new Node(key,val);
            head.next=p;
            p.pre=head;
            end=p;
        }
        else {
            Node p=new Node(key,val);
            Node temp=head.next;
            head.next=p;
            p.next=temp;
            p.pre=head;
            temp.pre=p;
        }
    }


    // 获取这个数，并更新这个数在链表的位置
    public int getVal(int key) {
        Node p=head.next;
        while(p!=null){
            //假如找到了
            if(p.key==key){
                int val=p.val;
                // 如果P在末尾,不能直接删除需要更改end位置
                if(p.next==null){
                    end=p.pre;
                    end.next=null;
                    add(key,val);
                    return val;
                }
                //P不在末尾
                else {
                    Node pre=p.pre;
                    Node next = p.next;
                    pre.next=next;
                    next.pre=pre;
                    add(key,val);
                    return val;
                }
            }
            p=p.next;
        }
        //找不到
        return -1;
    }
    // 容量未满时添加 注意:需要判断是更新还是添加
    public void NoFullADD(int key, int value) {
        Node p=head.next;
        while (p!=null){
            // 找到了 为更新,首先要删除他，在添加他
            if(p.key==key){
                //如果为末尾节点,记得更新end位置
                if(p.next==null){
                    end=p.pre;
                    end.next=null;
                    add(key,value);
                    return;
                }
                //如果为中间节点，
                else {
                    Node pre = p.pre;
                    Node next = p.next;
                    pre.next=next;
                    next.pre=pre;
                    add(key,value);
                    return;
                }
            }
            p=p.next;
        }

        //未找到，直接添加
        add(key,value);

    }

    //此时链表已满
    public void FullADD(int key, int value) {
        Node p =head.next;
        //如果P已经存在
        while(p!=null){
            if(p.key==key){
                //如果为末尾节点,记得更新end位置
                if(p.next==null){
                    end=p.pre;
                    end.next=null;
                    add(key,value);
                    return;
                }
                //如果为中间节点，
                else {
                    Node pre = p.pre;
                    Node next = p.next;
                    pre.next=next;
                    next.pre=pre;
                    add(key,value);
                    return;
                }

            }
            p=p.next;
        }
        // 如果P不存在，需要删除最后一个节点，在添加
        end=end.pre;
        end.next=null;
        add(key,value);
    }
}


class Node{
    Node pre;
    Node next;
    Integer key;
    Integer val;

    public Node() {
    }

    public Node(Integer key,Integer val) {
        this.key= key;
        this.val = val;
    }
}
zzu菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高频面试题_LRU缓存
0泡果奶的博客
02-23 451
双向链表和哈希表 这道题没有想象中的简单
【题解】LRU缓存
li1358159的博客
08-14 118
leetcode LRU缓存
leetcode面试题 16.25. LRU缓存
haoweng4800的博客
07-23 215
设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。写入数据 pu...
经典算法面试题：LRU缓存
07-06 527
题目 设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前
面试基础之LRU缓存机制
好想去看海
09-03 240
转载自https://leetcode-cn.com/problems/lru-cache/solution/lru-ce-lue-xiang-jie-he-shi-xian-by-labuladong/ 一、什么是 LRU 算法 就是一种缓存淘汰策略。 计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。但问题是，删除哪些内容呢？我们肯定希望删掉哪些没什么用的缓存，而把有用的数据继续留在缓存里，方便之后继续使用。那么，什么样的数据，我们判定为「有用的」的数据呢？ LRU 缓存淘汰算法就是一
牛客网 | 高频面试题 | 设计LRU缓存结构
我是一块小石头
12-20 190
文章目录题目解析 题目 设计LRU缓存结构_牛客网 示例1 输入 [[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3 返回值 [1,-1] 说明 第一次操作后：最常使用的记录为("1", 1) 第二次操作后：最常使用的记录为("2", 2)，("1", 1)变为最不常用的 第三次操作后：最常使用的记录为("3", 2)，("1", 1)还是最不常用的 第四次操作后：最常用的记录为("1", 1)，("2", 2)变为最不常用的 第五次操作后：
300-410 V16.25.pdf
04-10
CCNP300-410试题
300-410 V16.25.zip
07-13
300-410 V16.25.zip
LRUCache:Java中的简单LRU缓存。 “破解编码面试”中的问题16.25
04-28
Java中的简单LRU缓存。 “破解编码面试”中的问题16.25。 问题 设计用于Web查找的缓存机制，该机制将映射两个值，例如街道地址和营业税率。 假定这两个值是字符串，并且缓存具有最大大小并开始为空。 当达到最大大...
leetcode LRU缓存 Java实现
feat_ct的博客
05-22 563
面试题 16.25. LRU缓存 LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。 设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥
大厂常见面试题： 实现Lru缓存机制
BBinChina的专栏
09-14 227
文章目录前言一、c++ 实现简易版LruCacheListunordered_map二、Java 实现LruCache 前言 LruCache 也叫 最近最少使用缓存，在生产中经常使用到，用作内存缓存，配合redis可以实现二级缓存，提高服务器的处理性能，而在面试中，缓存是经常被问到的，如果候选人能讲出自己实现那么是很大加分项。 提示：以下是本篇文章正文内容，下面案例可供参考 一、c++ 实现简易版LruCache 主要运用数据结构：list、unordered_map List 采用链表方式来记录数
LRU算法,使用哈希表+双向链表实现缓存
gcs的博客
10-13 829
LRU即最近最少使用算法Least Recently Used：最近最少使用缓存；核心思想是“数据最近被访问过，那么将来被访问的几率会更高”； 这样能够保证：利用最少的空间实现高效的缓存； 实现方式是： 方式1：每次读取或者添加时保存一下时间戳，当内存需要清理的时候，就按照时间戳排序，然后去掉距离现在最远的。SDWebImage就是采用的了这样的方式。 方式2： 利用map实现迅速读取； 利用...
双链表实现LRU算法
恋恋风辰的技术博客
12-30 1096
链表 所谓链表就是一个节点指向另一个节点的数据结构，像一条链子把每个节点连接起来。 如果一个节点既指向了后面的节点，也指向了前面的节点，这些节点就构成了双向链表。 我们先定义这个节点结构 class NodeLRU { public: NodeLRU(int v) : val(v), prev(nullptr), next(nullptr) {} int val; NodeLRU *prev; NodeLRU *next; }; val为节点的数据域表示节点存储的数值 p
LeetCode之LRU缓存机制
shihao的博客
05-25 421
LRU缓存机制 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 进阶: 你是否.
采用双向链表手动实现LRU算法
nandao158的博客
04-07 777
采用双向链表手动实现LRU算法， redis有一种淘汰算法LRU策略，今天我们采用java语言双向链表分享一下： 1、leetcode描述； /** * * 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void pu..
HashMap+双向链表手写LRU缓存算法/页面置换算法
weixin_34097242的博客
01-31 232
import java.util.Hashtable; class DLinkedList { String key; //键 int value; //值 DLinkedList pre; //双向链表前驱 DLinkedList next; //双向链表后继 } public class LRUCache { private...
LRU手写 双向链表+哈希
weixin_54110641的博客
02-19 396
1.我们首先想到快速查询 应该使用哈希表 可以做到快速查询 但是没有固定顺序 2.于是想到又固定顺序还要增加复杂度低 就应该用链表 但是删除做不到常数级别 最终选择双向链表 3.我们可以把双向链表和哈希表得键相映射可以取得联系 2.首先我们应该创建出来一个双向链表 struct Dlist{ int val; int key; Dlist* pre; Dlist* next; Dlist():val(0),key(0),pre(nullptr),nex...
LRU实现（手动双向链表+HashMap；LinkedHashMap）
MagicSound的博客
03-23 421
方法一：手动 整体需要两个模块，HashMap用于存储key及其对应值，链表用于存储各个节点使用时间排序（因为要频繁删除、添加，用双向链表方便操作，时间复杂度降到O（1）） 首先构造双向链表节点类： class Node { int val; int key; Node pre; Node next; public Node(int key, int val) { this.key = key;
LRU-自建双向链表
qq_36465247的博客
08-03 88
LRU-自建双向链表 使用LinkedHashMap的同学可以歇歇了，面试你用LinkedHashMap试试 ???? 所以这里提供自建方案1。 import java.util.*; public class Solution { // 链表节点，用于存放数据，为HashMap提供顺序 private class Node { int key; int value; Node pre; Node next;
600000.SH 浦发银行 2015-1-5 15.69 15.88 16.25 15.56 16.07 3.4415
最新发布
07-25
根据你提供的示例数据行，每一列之间似乎是使用制表符或者空格作为分隔符。所以，你可以尝试使用制表符或者空格来分割每个字段。 以下是你提供数据行的字段分割示例： - 列1: 600000.SH - 列2: 浦发银行 - 列3: 2015-1-5 - 列4: 15.69 - 列5: 15.88 - 列6: 16.25 - 列7: 15.56 - 列8: 16.07 - 列9: 3.4415 请确保在处理整个数据集时，每一行都按照相同的分隔符进行分割，并且每个字段都正确地表示了相应的数据。 如果你对数据处理有进一步的需求或有其他问题，请告诉我。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值