LRU Cache

最新推荐文章于 2025-04-12 19:22:15 发布

原创最新推荐文章于 2025-04-12 19:22:15 发布 · 266 阅读

0 ·

CC 4.0 BY-SA版权

刷遍数专栏收录该内容

260 篇文章

订阅专栏

本文介绍了一种使用双向链表和哈希表实现的LRU(Least Recently Used)缓存淘汰策略。通过定义内部Node类来维护双向链表结构，并使用HashMap存储键值对，实现了快速查找和更新节点的功能。当缓存满时，会自动移除最近最少使用的项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

public class LRUCache {
    private class Node {
        int key;
        int val;
        Node next;
        Node prev;
        public Node(int key, int val) {
            this.key = key;
            this.val = val;    
        }
    }

    int size = 0;
    Map<Integer, Node> map = new HashMap<>();
    Node head = new Node(-1, -1);
    Node tail = new Node(-1, -1);
    public LRUCache(int capacity) {
        size = capacity;
        head.next = tail;
        head.prev = tail;
        tail.next = head;
        tail.prev = head;
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        Node node = map.get(key);
        node.prev.next = node.next;
        node.next.prev = node.prev;
        moveToTail(node);
        return node.val;
    }

    public void set(int key, int value) {
        if (get(key) != -1) {
            Node node = map.get(key);
            node.val = value;
            return;
        }
        if (size == map.size()) {
            Node deletedNode = head.next;
            head.next = deletedNode.next;
            deletedNode.next.prev = head;
            map.remove(deletedNode.key);
        }
        Node node = new Node(key, value);
        map.put(key, node);
        moveToTail(node);
    }
    
    private void moveToTail(Node node) {
        node.next = tail;
        node.prev = tail.prev;
        tail.prev.next = node;
        tail.prev = node;
    }
}