力扣labuladong一刷day52天LRU算法

力扣labuladong一刷day52天LRU算法

文章目录

概念

LRU的全称为Least Recently Used,翻译出来就是最近最少使用的意思,它是一种内存淘汰算法,当内存不够时,将内存中最久没使用的数据清理掉。 LUR算法是内存管理的一种页面置换算法,就是用来删除内存中不被使用的数据,腾出空间来把常用的数据存进去。

一、146. LRU 缓存

题目链接:https://leetcode.cn/problems/lru-cache/

思路一:使用双向链表加map来手动实现。
java 复制代码
class Node {
    public int key, val;
    public Node next, prev;
    public Node(int k, int v) {
        key = k;
        val = v;
    }
}

class DoubleList{
    private Node head, tail;
    private int size;

    public DoubleList() {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }

    void addLast(Node x) {
        x.next = tail;
        x.prev = tail.prev;
        tail.prev.next = x;
        tail.prev = x;
        size++;
    }

    void remove(Node x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
        size--;
    }

    Node removeFirst() {
        if (head.next == tail) {
            return null;
        }
        Node first = head.next;
        remove(first);
        return first;
    }
    int size() {
        return size;
    }
}

class LRUCache{
    private HashMap<Integer, Node> map;
    private DoubleList cache;
    private int cap;

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        makeRecently(key);
        return map.get(key).val;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            deleteKey(key);
            addRecently(key, value);
            return;
        }
        if (cap == cache.size()) {
            deleteLastRecently();
        }
        addRecently(key, value);
    }

    public LRUCache(int capacity) {
        this.cap = capacity;
        this.map = new HashMap<>();
        this.cache = new DoubleList();
    }

    private void makeRecently(int key) {
        Node node = map.get(key);
        cache.remove(node);
        cache.addLast(node);
    }

    private void addRecently(int key, int value) {
        Node node = new Node(key, value);
        map.put(key, node);
        cache.addLast(node);
    }

    private void deleteKey(int key) {
        Node node = map.remove(key);
        cache.remove(node);
    }

    private void deleteLastRecently() {
        Node node = cache.removeFirst();
        map.remove(node.key);
    }

}

/**
 * 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);
 */
思路二:使用LinkedHashMap

put都是从尾部加入,要想删除头部可以使用map.keySet().iterator().next();拿到key,然后删除。

java 复制代码
class LRUCache {
    LinkedHashMap<Integer, Integer> map;
    int cap = 0;
    public LRUCache(int capacity) {
        map = new LinkedHashMap<>();
        cap = capacity;
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        Integer val = map.remove(key);
        map.put(key, val);
        return val;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            map.remove(key);
            map.put(key, value);
            return;
        }
        if (cap <= map.size()) {
            Integer first = map.keySet().iterator().next();
            map.remove(first);
        }
        map.put(key, value);
    }
}
相关推荐
田里的水稻17 分钟前
C++_队列编码实例,从末端添加对象,同时把头部的对象剔除掉,中的队列长度为设置长度NUM_OBJ
java·c++·算法
纪元A梦25 分钟前
贪心算法应用:保险理赔调度问题详解
算法·贪心算法
Jayden_Ruan1 小时前
C++逆向输出一个字符串(三)
开发语言·c++·算法
点云SLAM2 小时前
C++ 常见面试题汇总
java·开发语言·c++·算法·面试·内存管理
叙白冲冲2 小时前
哈希算法以及面试答法
算法·面试·哈希算法
YuTaoShao3 小时前
【LeetCode 每日一题】1277. 统计全为 1 的正方形子矩阵
算法·leetcode·矩阵
古译汉书4 小时前
嵌入式铁头山羊stm32-ADC实现定时器触发的注入序列的单通道转换-Day26
开发语言·数据结构·stm32·单片机·嵌入式硬件·算法
野犬寒鸦4 小时前
力扣hot100:相交链表与反转链表详细思路讲解(160,206)
java·数据结构·后端·算法·leetcode
阿昭L4 小时前
leetcode两数之和
算法·leetcode
周树皮不皮4 小时前
【Leetcode100】算法模板之二叉树
算法