146. LRU Cache

class LRUCache {

    private static class Node {
        private final int key;
        private int val;
        private Node prev;
        private Node next;

        public Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    private final int capacity;
    private final Map<Integer, Node> cacheMap;
    private final Node dummyHead;
    private final Node dummyTail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cacheMap = new HashMap<>();
        this.dummyHead = new Node(-1, -1);
        this.dummyTail = new Node(-1, -1);
        this.dummyHead.next = this.dummyTail;
        this.dummyTail.prev = this.dummyHead;
    }

    public int get(int key) {
        Node node = cacheMap.get(key);
        if (node == null) {
            return -1;
        } else {
            moveToHead(node);
            return node.val;
        }
    }

    private void moveToHead(Node node) {
        removeNode(node);
        addToHead(node);
    }

    private void addToHead(Node node) {
        Node head = dummyHead.next;
        head.prev = node;
        dummyHead.next = node;

        node.prev = dummyHead;
        node.next = head;
    }

    private void removeNode(Node node) {
        Node prev = node.prev;
        Node next = node.next;
        prev.next = next;
        next.prev = prev;
    }

    public void put(int key, int value) {
        Node node = cacheMap.get(key);
        if (node == null) {
            node = new Node(key, value);
            addToHead(node);
            cacheMap.put(key, node);
            if (cacheMap.size() > capacity) {
                Node tail = dummyTail.prev;
                removeNode(tail);
                cacheMap.remove(tail.key);
            }
        } else {
            node.val = value;
            moveToHead(node);
        }
    }

}

注意是双向链表，移动节点时需要注意修改前后两个节点的指针。

Reference

146. LRU Cache
面试题 16.25. LRU 缓存
剑指 Offer II 031. 最近最少使用缓存