【Hot100】LeetCode—146. LRU 缓存

山脚ice2024-08-22 9:06

目录

  • 1-思路
    • [1-1 LRU知识点](#1-1 LRU知识点)
    • [1-2 实现思路](#1-2 实现思路)
      • LRU的子数据结构
        • [① 双向链表 DLinkedNode 结点定义](#① 双向链表 DLinkedNode 结点定义)
        • [② 其他字段](#② 其他字段)
      • LRU实现的方法
        • [① 初始化------LRUCache中初始化](#① 初始化——LRUCache中初始化)
        • [② public int get(int key) 取元素方法](#② public int get(int key) 取元素方法)
        • [③ public void put(int key, int value) 存元素方法](#③ public void put(int key, int value) 存元素方法)
  • 2-实现
    • [⭐146. LRU 缓存------题解思路](#⭐146. LRU 缓存——题解思路)
  • [3- ACM实现](#3- ACM实现)

1-思路

1-1 LRU知识点

  • LRU ：最近最少使用算法，如果经常请求的数据不会被淘汰，会被淘汰的是最近最少请求的数据。
  • 热门数据会往上排列
  • 看到 LRU，就想到 LRU 对应的数据结构 ------> HashMap + 双向链表(DLinkedNode)

1-2 实现思路

LRU 算法的具体步骤

  • 1- 头插： 新数据直接插入到列表头部
  • 2- 移动到头： 缓存数据被命中，将数据移动到列表头部
  • 3- 删除尾部： 缓存已经满的时候，移除列表尾部数据

LRU的子数据结构

① 双向链表 DLinkedNode 结点定义
  • 包含 key 、value，key 就是 HashMap 的 key
java 复制代码 
class DLinkedNode{
    int key;
    int value;
    DLinkedNode pre;
    DLinkedNode next;
    DLinkedNode(){}
    DLinkedNode(int k,int v){key = k; value = v;}
}
② 其他字段
  • cache ：缓存 Map<Integer,DLinkedNode> ：key 放 key，value 放值
  • size：当前缓存中的元素个数
  • capacity：缓存的容量
  • DLinkedNode head,tail：定义双向链表的头尾结点
java 复制代码 
Map<Integer,DLinkedNode> cache = new HashMap<Integer,DLinkedNode>();
int size;
int capacity;
DLinkedNode head,tail;

LRU实现的方法

① 初始化------LRUCache中初始化
  • 根据 capacity 传入的容量进行初始化
java 复制代码 
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.pre = head;
    }
② public int get(int key) 取元素方法

获取元素涉及到的方法如下

  • 1- public int get(int key)：
    • 通过 key 获取元素，直接使用 map 的get方法
    • 若不存在，返回 -1
    • 若存在，先将其 moveToHead(DLinkedNode node) 再返回
  • 2- moveToHead(DLinkedNode node)
    • private DLinkedNode remove(DLinkedNode node)：先删除node元素
    • private void addToHead(DLinkedNode node)再添加到头
  • 3- remove(DLinkedNode node)
    • 双链表 删除 node 结点
  • 4- addToHead(DLinkedNode node)
    • 双链表头插
③ public void put(int key, int value) 存元素方法
  • 添加元素思考：
    • 当前元素不存在，直接添加，添加过程中需要判断缓存是否已满
    • 若存在，更新 value 即可

2-实现

⭐146. LRU 缓存------题解思路


java 复制代码 
class LRUCache {

    public class DLinkedNode{
        int key;
        int val;
        DLinkedNode pre;
        DLinkedNode next;
        DLinkedNode(){}
        DLinkedNode(int k,int v){
            key = k;
            val = v;
        }
    }
    // 定义 LRU 所需要的变量
    HashMap<Integer,DLinkedNode> cache = new HashMap<>();
    int capacity;
    int size;
    DLinkedNode head,tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.pre = head;
    }
    
    public int get(int key) {
        // get 元素
        DLinkedNode node = cache.get(key);
        if(node==null){
            return -1;
        }
        // 双链表操作
        moveToHead(node);
        return node.val;
    }

    private void moveToHead(DLinkedNode node){
        remove(node);
        addToHead(node);
    }

    private void remove(DLinkedNode node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    
    private void addToHead(DLinkedNode node){
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
        node.pre = head;
    }

    public void put(int key, int value) {
        // 要判断是更新还是新增
        DLinkedNode node = cache.get(key);
        if(node==null){
            DLinkedNode newNode = new DLinkedNode(key,value);
            cache.put(key,newNode);
            size++;
            addToHead(newNode);
            if(size>capacity){
                DLinkedNode last = removeLast();
                cache.remove(last.key);
                size--;
            }
        }else{
            node.val = value;
            moveToHead(node);
        }
    }

    public DLinkedNode removeLast(){
        DLinkedNode last = tail.pre;
        remove(last);
        return last;
    }
}

3- ACM实现

java 复制代码 
import java.util.HashMap;
import java.util.Scanner;


public class LRUCache {


    // 1- 定义数据
    class DLinkedNode{
        int key;
        int value;
        DLinkedNode pre;
        DLinkedNode next;
        DLinkedNode(){}
        DLinkedNode(int k,int v){
            key = k;
            value = v;
        }
    }
    int size;
    int capacity;
    DLinkedNode head,tail;
    HashMap<Integer,DLinkedNode> cache = new HashMap<>();

    // 2- 初始化
    public LRUCache(int capacity){
        this.capacity = capacity;
        this.size = 0;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.pre = head;
    }


    // 3- 实现 LRU 的get方法
    public int get(int key){
        DLinkedNode node = cache.get(key);
        if(node== null){
            return -1;
        }
        moveToHead(node);
        return node.value;
    }

    private void moveToHead(DLinkedNode node){
        remove(node);
        addToHead(node);
    }

    private void remove(DLinkedNode node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    private void addToHead(DLinkedNode node){
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
        node.pre = head;
    }

    // 4- 实现 LRU 的put方法
    public void put(int key,int value){
        DLinkedNode node = cache.get(key);
        if(node==null){
            node = new DLinkedNode(key,value);
            cache.put(key,node);
            addToHead(node);
            size++;
            if(size>capacity){
                DLinkedNode ttail = removeTail();
                cache.remove(ttail.key);
                size--;
            }
        }
    }

    private DLinkedNode removeTail(){
        DLinkedNode node = tail.pre;
        remove(node);
        return node;
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入cache缓存容量capacity");
        int capacity = scanner.nextInt();
        LRUCache cache = new LRUCache(capacity);
        while (scanner.hasNext()) {
            String operation = scanner.next();
            if (operation.equals("get")) {
                int key = scanner.nextInt();
                System.out.println(cache.get(key));
            } else if (operation.equals("put")) {
                int key = scanner.nextInt();
                int value = scanner.nextInt();
                cache.put(key, value);
            }
        }
        scanner.close();
    }
}
相关推荐
88号技师17 分钟前
2024年12月一区SCI-加权平均优化算法Weighted average algorithm-附Matlab免费代码
人工智能·算法·matlab·优化算法
IT猿手17 分钟前
多目标应用（一）：多目标麋鹿优化算法（MOEHO）求解10个工程应用，提供完整MATLAB代码
开发语言·人工智能·算法·机器学习·matlab
88号技师18 分钟前
几款性能优秀的差分进化算法DE（SaDE、JADE，SHADE，LSHADE、LSHADE_SPACMA、LSHADE_EpSin）-附Matlab免费代码
开发语言·人工智能·算法·matlab·优化算法
我要学编程(ಥ_ಥ)1 小时前
一文详解“二叉树中的深搜“在算法中的应用
java·数据结构·算法·leetcode·深度优先
埃菲尔铁塔_CV算法1 小时前
FTT变换Matlab代码解释及应用场景
算法
许野平2 小时前
Rust: enum 和 i32 的区别和互换
python·算法·rust·enum·i32
chenziang12 小时前
leetcode hot100 合并区间
算法
chenziang12 小时前
leetcode hot100 对称二叉树
算法·leetcode·职场和发展
04Koi.2 小时前
Redis--常用数据结构和编码方式
数据库·redis·缓存
szuzhan.gy2 小时前
DS查找—二叉树平衡因子
数据结构·c++·算法
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10STM32 无法烧录