LeetCode-146-LRU缓存

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

目录

题目

在这里插入图片描述

思路

  1. 看题意字面意思应该还是理解的，但是我记得要用双向链表+HashMap什么的，所以应该不像题目看起来这么简单，直接润去题解。
  2. 对于已经构建好的LRU缓存，操作解释如下
        //创建缓存长度为2的LRU缓存机制
        LRUCache cache = new LRUCache(2);
        // 可以把 cache 理解成一个队列
        // 假设左边是队头，右边是队尾
        // 最近使用的排在队头，久未使用的排在队尾
        // 圆括号表示键值对 (key, val)

        cache.put(1, 1);
        // cache = [(1, 1)]

        cache.put(2, 2);
        // cache = [(2, 2), (1, 1)]

        cache.get(1);       // 返回 1
        // cache = [(1, 1), (2, 2)]
        // 解释：因为最近访问了键 1，所以提前至队头
        // 返回键 1 对应的值 1

        cache.put(3, 3);
        // cache = [(3, 3), (1, 1)]
        // 解释：缓存容量已满，需要删除内容空出位置
        // 优先删除久未使用的数据，也就是队尾的数据
        // 然后把新的数据插入队头

        cache.get(2);       // 返回 -1 (未找到)
        // cache = [(3, 3), (1, 1)]
        // 解释：cache 中不存在键为 2 的数据

        cache.put(1, 4);
        // cache = [(1, 4), (3, 3)]
        // 解释：键 1 已存在，把原始值 1 覆盖为 4
        // 不要忘了也要将键值对提前到队头
  1. 可以看出来，比起算法，这道题意思更是让我们写数据结构，其中get和put都必须以O（1）的平均时间复杂度运行。
  2. 很明显，在插入删除上，可以考虑使用双向链表，而在数据的保存和查找上，可以考虑使用哈希表查找。结合前面两点，形成一个新的数据结构:哈希链表。
  3. 必须选择双向链表的原因是我们经常需要进行动态的删除，此时必须知道节点前驱的消息，所以双向链表会方便一点。

思路代码

双向链表Node节点

//创建双链表的节点类
class Node{
    public int key,val; //kay和value
    public Node next,prev; //前后两节点
    public Node(int k,int v){//创建函数
        this.key=k;
        this.val=v;
    }
}

根据节点创建双向链表

注意里面只写了从尾部添加的方法，所以默认为靠近尾部的为较新的，靠近头部的为较久的

//根据节点，创建双链表
class DoubleLink{
    //头尾虚节点 至于为什么需要虚节点 推测应该是因为头尾经常需要互换 所以使用虚节点方便计算
    private Node head,tail;
    //链表元素数
    private int size;

    //构造函数
    public DoubleLink(){
        //初始化双向链表的数据 头尾节点 和size
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next=tail;
        tail.prev=head;
        size=0;
    }
    //在链表尾部添加节点 时间复杂度O（1）
    public void addLast(Node x){
        x.prev = tail.prev;
        x.next=tail;
        tail.prev.next=x;
        tail.prev=x;
        size++;
    }
    //删除链表中的元素 因为之前会用hashmap查询 所以x一定存在
    public void remove(Node x){
        x.next.prev = x.prev;
        x.prev.next = x.next;
        size--;
    }
    //删除链表的第一个节点，并返回该节点
    public Node removeFirst(){
        //注意特殊情况
        if(head.next==tail) return null;
//        head.next.next.prev = head;
//        head.next=head.next.next;
//        size--;
        //好像可以直接调用 不过像我上面这样写应该也可以？
        Node temp = head.next;
        remove(temp);
        return head;
    }
    //返回链表的size
    public int size() { return size; }
}

结合双向链表和HashMap创建LRUCache

class LRUCache {
    //哈希表 注意一下 哈希表需要和链表链接起来，因为链表可以存储key value 而查找的时候只需要知道key
    //所以哈希表定为<key Node>
    private HashMap<Integer,Node>map;
    //双向链表 存储具体数据
    private DoubleLink cache;
    //最大容量
    private int cap;

    public LRUCache(int capacity) {
        //创建函数时很明显 创建对应的哈希表 双向链表 设定容量
        this.cap = capacity;
        this.map = new HashMap<Integer,Node>();
        this.cache = new DoubleLink();
    }
}

写几个避免get和put函数直接操作双向链表和map的辅助函数

  1. 将key对应的节点提升为最近使用的节点
  2. 添加新元素
  3. 删除key
  4. 删除最久没使用的元素
    //将key对应的节点提升为最近使用的节点
    private void MakeRecently(int key){
        Node x = map.get(key);
        //从链表中删除这个节点 然后把这个节点重新加入队尾
        cache.remove(x);
        cache.addLast(x);
    }
    
    //添加新元素
    private void addRencently(int key,int val){
        //直接创建node
        Node x  = new Node(key,val);
        //put进map
        map.put(key,x);
        //在cache里进行修改
        cache.addLast(x);
    }
    //删除一个key
    private void DeleteKey(int key){
        //获取对应的node
        Node x = map.get(key);
        //哈希表里面删除
        map.remove(key);
        //cache里删除
        cache.remove(x);
    }
    //删除最久没使用的元素
    private void removeLastRecently(){
        //要先获取被cache删除的节点 需要在map里删除
        Node deleteNode = cache.removeFirst();
        //移除cache里的最后一个即可
        map.remove(deleteNode.key);
    }

get()和put()

    //题目要求为如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
    public int get(int key) {
        if(map.containsKey(key)){
            //首先提到最近使用的节点
            MakeRecently(key);
            return map.get(key).val;
        }else return -1;
    }
    //题目要求为如果关键字key已经存在，则变更其数据值为value
    // 如果不存在，则向缓存中插入该组key-value
    // 如果插入操作导致关键字数量超过capacity ，则应该 逐出 最久未使用的关键字。

    public void put(int key, int value) {
        //如果关键字存在
        if(map.containsKey(key)){
            //删除旧元素 添加新元素 因为写那个方法的时候没有判断重复 所以必须让它不重复
            DeleteKey(key);
            addRencently(key,value);
        }else { //判断当前cap和总容量的关系
            if(cache.size()==this.cap){
                removeLastRecently();
            }
            //加入
            addRencently(key,value);
        }
    }

总代码

import java.util.HashMap;

//创建双链表的节点类
class Node{
    public int key,val; //kay和value
    public Node next,prev; //前后两节点
    public Node(int k,int v){//创建函数
        this.key=k;
        this.val=v;
    }
}
//根据节点，创建双链表
class DoubleLink{
    //头尾虚节点 至于为什么需要虚节点 推测应该是因为头尾经常需要互换 所以使用虚节点方便计算
    private Node head,tail;
    //链表元素数
    private int size;

    //构造函数
    public DoubleLink(){
        //初始化双向链表的数据 头尾节点 和size
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next=tail;
        tail.prev=head;
        size=0;
    }
    //在链表尾部添加节点 时间复杂度O（1）
    public void addLast(Node x){
        x.prev = tail.prev;
        x.next=tail;
        tail.prev.next=x;
        tail.prev=x;
        size++;
    }
    //删除链表中的元素 因为之前会用hashmap查询 所以x一定存在
    public void remove(Node x){
        x.next.prev = x.prev;
        x.prev.next = x.next;
        size--;
    }
    //删除链表的第一个节点，并返回删除的那个节点
    public Node removeFirst(){
        //注意特殊情况
        if(head.next==tail) return null;
//        head.next.next.prev = head;
//        head.next=head.next.next;
//        size--;
        //好像可以直接调用 不过像我上面这样写应该也可以？
        Node temp = head.next;
        remove(temp);
        return temp;
    }
    //返回链表的size
    public int size() { return size; }
}
public class LRUCache {
    //哈希表 注意一下 哈希表需要和链表链接起来，因为链表可以存储key value 而查找的时候只需要知道key
    //所以哈希表定为<key Node>
    private HashMap<Integer,Node>map;
    //双向链表 存储具体数据
    private DoubleLink cache;
    //最大容量
    private int cap;

    public LRUCache(int capacity) {
        //创建函数时很明显 创建对应的哈希表 双向链表 设定容量
        this.cap = capacity;
        this.map = new HashMap<Integer,Node>();
        this.cache = new DoubleLink();
    }
    //将key对应的节点提升为最近使用的节点
    private void MakeRecently(int key){
        Node x = map.get(key);
        //从链表中删除这个节点 然后把这个节点重新加入队尾
        cache.remove(x);
        cache.addLast(x);
    }
    //添加新元素
    private void addRencently(int key,int val){
        //直接创建node
        Node x  = new Node(key,val);
        //put进map
        map.put(key,x);
        //在cache里进行修改
        cache.addLast(x);
    }
    //删除一个key
    private void DeleteKey(int key){
        //获取对应的node
        Node x = map.get(key);
        //哈希表里面删除
        map.remove(key);
        //cache里删除
        cache.remove(x);
    }
    //删除最久没使用的元素
    private void removeLastRecently(){
        //要先获取被cache删除的节点 需要在map里删除
        Node deleteNode = cache.removeFirst();
        //移除cache里的最后一个即可
        map.remove(deleteNode.key);
    }

    //题目要求为如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
    public int get(int key) {
        if(map.containsKey(key)){
            //首先提到最近使用的节点
            MakeRecently(key);
            return map.get(key).val;
        }else return -1;
    }
    //题目要求为如果关键字key已经存在，则变更其数据值为value
    // 如果不存在，则向缓存中插入该组key-value
    // 如果插入操作导致关键字数量超过capacity ，则应该 逐出 最久未使用的关键字。

    public void put(int key, int value) {
        //如果关键字存在
        if(map.containsKey(key)){
            //删除旧元素 添加新元素 因为写那个方法的时候没有判断重复 所以必须让它不重复
            DeleteKey(key);
            addRencently(key,value);
        }else { //判断当前cap和总容量的关系
            if(cache.size()==this.cap){
                removeLastRecently();
            }
            //加入
            addRencently(key,value);
        }
    }
}
z754916067
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode经典题 LRU缓存
weixin_47414034的博客
12-10 293
此时如果你push 3进去，此时超出了cache的容量，于是需要移除最不常用的2（也就是处在队尾的是最不常用），然后将3放进去，此时队列是3，1，由于3是刚刚put进去的，所以3处于队首，1处于队尾。3.这道题目其实就是就是让你写两个方法，get方法和put方法，get方法是给定某个结点的key获取这个结点的value，put方法是把某个结点添加进队列里面。4.这道题目还在队列的前后各自加了一个dummy结点（head，tail），dummy结点并不会真的用到，但是有这两个结点，很多操作会变得很容易。
【LeetCode 146】LRU缓存
小鱼学编程
07-07 2206
今天我们来讲解一道面试高频算法题 LeetCode146题 LRU缓存
LeetCode 146：LRU 缓存
机械工程跑路哥
07-20 862
因为在删除节点时，使用removeFirst()删除链表头部也就是最长时间未使用的节点，然后需要再根据该方法返回的这个节点的key，去删除hashmap中对应的键值对；而事实上，在一个时间段内，只需要访问一小部分数据即可正常运行，这就导致内存中驻留了大量用不到的数据；因为删除链表时，双向链表的前驱操作可以保证时间复杂度为O(1)，而单向链表的删除要从头遍历直到找到节点，时间复杂度为O(n)；LRU的全称是LeastRecentlyUsed，也就是说我们认为最近使用过的数据应该是是「有用的」，........
Leetcode.146.LRU缓存机制
qq_43164662的博客
10-07 887
设计题：LRU：双向链表+HashMap
LeetCodes刷题总结7——LRU缓存
weixin_53111016的博客
05-11 774
题目 146. LRU 缓存 - 力扣（LeetCode） 请你设计并实现一个满足LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value)如果关键字key 已经存在，则变更其数据值value ...
lrucacheleetcode-Leetcode-LRU-cache:146.LRU缓存
06-29
lru缓存leetcode Leetcode-LRU-cache LRU缓存 设计和实现最近最少使用 (LRU) 缓存的数据结构。 它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（将始终为正），否则返回 -1。 put...
lrucacheleetcode-LRUCache-Leetcode-146:LRU（最近最少使用）缓存的两个独立实现。第一个利用“map.k
06-29
lru缓存leetcode LRUCache-Leetcode-146 Leetcode 第 146 题（中） 问题中使用的技术：Hashmap、设计 注意：代码中有两个单独的 LRU（最近最少使用）缓存实现。 第一个利用“map.keys()”，它按照插入顺序返回哈希图...
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-146-LRU缓存机制1
07-25
示例// 返回 1// 该操作会使得密钥 2 作废// 返回 -1 (未找到)// 该操作会使得密钥 1 作废// 返回 -1 (未找到)// 返回 3// 返
lyj2014211626#Prepare_For_AI_Job#leetcode-146. LRU缓存机制1
07-25
146. LRU缓存机制参考解法官方解法解法：双链接 + 哈希表* Your LRUCache object will be instantiated and
open-gap#Leetcode-Road#146.LRU缓存机制1
07-25
解法一：使用哈希表与双向链表的组合结构，又称为哈希链表 (题解)//双链表的容量// 使用list的迭代器可以在O(1)时间内完成元素删除操作**// 访问的
LeetCode146——LRU缓存机制
热门推荐
清风阁
01-09 1万+
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/lru-cache/description/ 题目描述： 知识点：哈希表、双向链表、LRU缓存机制 思路一：用哈希表记录键值对，用双向链表处理LRU缓存机制 用示例来说明我们算法的流程，为了防止对null节...
leetcode链表之LRU缓存
溪语流沙的博客
03-15 959
146、LRU缓存 题目 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-val
LeetCode LRU缓存
TranSad的博客
01-11 725
146. LRU 缓存 请你设计并实现一个满足LRU (最近最少使用) 缓存约束的数据结构。 实现LRUCache类： LRUCache(int capacity)以正整数作为容量capacity初始化 LRU 缓存 int get(int key)如果关键字key存在于缓存中，则返回关键字的值，否则返回-1。 void put(int key, int value)如果关键字key已经存在，则变更其数据值value；如果不存在，则向缓存中插入该组key-...
LeetCode每日一练： LRU缓存机制
刘猿猿
05-24 4311
题目描述 题目难度：★★★★ 这是一道LeetCode上的算法题， 题目地址：LRUCache 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - ...
LeetCode 高级 - LRU 缓存机制
whdAlive 's blog
08-04 2575
LRU 缓存机制 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据...
LeetCode 146 LRUCache Python题解
日复一日，年复一年
04-18 4960
LRUCache全名为Least Recently Used，即最近最少使用算法，是操作系统中发生缺页中断时常用的一种页面置换算法。根据局部性原理，最近使用的数据块很有可能继续被频繁使用，因此当Cache已满的时候，LRUCache算法会把最久未使用的数据块替换出去。对于LRU算法主要实现两个操作： 访问数据块 将访问的数据块更新为最近访问，并返回访问的数据块。 添加数据块 如果Cache还有
Leetcode——LRU 缓存机制
Yawn
08-07 142
1. 题目 2. 题解 双链表中实现的方法： 链表初始化 添加元素到双链表尾部（同时意味着该元素最近使用过） 删除某个结点（非头结点） 删除并返回头结点（意味着移除最久未使用过的元素） 返回链表当前长度 LRU 缓存中的方法： 初始化，get，put方法 设置某元素最近已使用makeRecently（原map中已有该元素） 添加最近使用过的元素addRecently（原map中不存在该键值对，新元素） 删除某个key对应的元素 删除最久未使用过的元素 2.中的方法也可以直接在get和put方法中实现
剑指offer/LeetCode146/LintCode134_LRU缓存实现
weixin_33828101的博客
04-16 179
剑指offer/LeetCode146/LintCode134_LRU缓存实现 声明 文章均为本人技术笔记，转载请注明出处[1] https://segmentfault.com/u/yzwall[2] blog.csdn.net/j_dark/ 解题思路 LRU缓存两种功能： get(key)：获取key的对应value，不存在返回-...
LeetCode：146. LRU 缓存
Bertil的博客
04-24 840
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键
idea leetcode-edito乱码
最新发布
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值