LRU 缓存机制

LRU 缓存机制

牛客LRU

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类：

• LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
• int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value)如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：

输入 [“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”,“get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1],[3], [4]]
输出 [null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

解法

class LRUCache {
    class Node {
        int key, val;
        Node next;
        Node prev;
        public Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }
    class DoubleList{
        private Node head;
        private Node tail;
        private int size;
        // 在链表头部添加节点 x，时间 O(1)
        public void addFirst(Node x){
            if(head==null){
                head=x;
                tail=x;
            }else {
                x.next=head;
                head.prev=x;
                head=x;
            }
            size++;
        }

        // 删除链表中的 x 节点（x 一定存在）
        // 由于是双链表且给的是目标 Node 节点，时间 O(1)
        public void remove(Node x){
            if (head==x&&tail==x){
                head=null;
                tail=null;
            }else if(head==x){
                head.next.prev=null;
                head=x.next;
            }else if(tail==x){
                x.prev.next=null;
                tail=x.prev;
            }else {
                x.prev.next=x.next;
                x.next.prev=x.prev;
            }
            size--;
        }

        // 删除链表中最后一个节点，并返回该节点，时间 O(1)
        public Node removeLast(){
            Node node=tail;
            remove(tail);
            return node;
        }

        // 返回链表长度，时间 O(1)
        public int size(){
            return size;
        }
    }

    private HashMap<Integer,Node> map;
    private DoubleList doubleList;
    private int capacity=0;
    public LRUCache(int capacity) {
        map=new HashMap<>();
        doubleList=new DoubleList();
        this.capacity=capacity;
    }

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

    public void put(int key, int value) {
        Node x=new Node(key,value);
        if(map.containsKey(key)){
            doubleList.remove(map.get(key));
            doubleList.addFirst(x);
            map.put(key,x);
        }else {
            if (capacity==doubleList.size()){
                Node last=doubleList.removeLast();
                map.remove(last.key);
            }
            doubleList.addFirst(x);
            map.put(key,x);
        }
    }
}