[LeetCode] 146. LRU Cache

Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.

Implement the LRUCache class:

• LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
• int get(int key) Return the value of the key if the key exists, otherwise return -1.
• void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.

Follow up:
Could you do get and put in O(1) time complexity?

Example 1:

Input
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
Output
[null, null, null, 1, null, -1, null, -1, 3, 4]

Explanation
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // cache is {1=1}
lRUCache.put(2, 2); // cache is {1=1, 2=2}
lRUCache.get(1);    // return 1
lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
lRUCache.get(2);    // returns -1 (not found)
lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
lRUCache.get(1);    // return -1 (not found)
lRUCache.get(3);    // return 3
lRUCache.get(4);    // return 4

Constraints:

• 1 <= capacity <= 3000
• 0 <= key <= 3000
• 0 <= value <= 104
• At most 3 * 104 calls will be made to get and put.

LRU缓存器。

实现这个缓存器，时间复杂度要求是O(1)。LRU缓存器是在一定的容量范围内存了一些node，按照上一次被访问的时间由新到旧排列，越近被访问的node应该排得越靠前。有几个函数需要实现。

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

思路是双向链表（DLL） + hashmap。因为题意要求了时间复杂度必须是O(1)所以只有hashmap才能满足这个时间复杂度。至于为什么是DLL而不是单链表，则是为了node之间的移动方便，也是为了添加删除节点的时候能更加高效。这里解释一下两个函数的实现细节。

get函数，就是在hashmap里面寻找目标。如果有则先删除这个目标，再加进去，再返回，没有则返回-1；同时DLL里面，如果没有这个目标则什么都不做，如果有这个目标则需要把这个node移动到头节点。

put函数，如果node之前存在过，则hashmap没有动作，DLL里面需要把这个node放到头节点；如果node不存在，需要看一下此时此刻node的数量是否超过cache的容量capacity，如果没超过就直接把node放到DLL的头节点，放入hashmap并size++，如果超过了capacity，要先去掉DLL的tail节点，再加入当前节点。

时间O(1) - required

空间O(n) - hashmap + DLL

Java实现

class LRUCache {
    class Node {
        int key;
        int value;
        Node prev;
        Node next;
    }

    private void addNode(Node node) {
        // always add the node after the head
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

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

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

    private Node popTail() {
        Node res = tail.prev;
        removeNode(res);
        return res;
    }

    private HashMap<Integer, Node> cache = new HashMap<>();
    private int size;
    private int capacity;
    private Node head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) {
            return -1;
        }
        moveToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        Node node = cache.get(key);
        if (node == null) {
            Node newNode = new Node();
            newNode.key = key;
            newNode.value = value;
            cache.put(key, newNode);
            addNode(newNode);
            size++;
            if (size > capacity) {
                Node tail = popTail();
                cache.remove(tail.key);
                size--;
            }
        } else {
            node.value = value;
            moveToHead(node);
        }
    }
}

/**
 * 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);
 */

JavaScript实现

ES6里面的hashmap有一个特性，是加入hashmap里面的object是有序的，所以如果用ES6写这道题的话是不需要DLL的。用map.prototype.keys()得到一个迭代器（iterator），然后用.next().value获取到map里面最老的一个节点然后将其删除。我这里给出两种实现，第一种不需要DLL，第二种需要。

/**
 * @param {number} capacity
 */
var LRUCache = function (capacity) {
    this.capacity = capacity;
    this.cache = new Map();
};

/** 
 * @param {number} key
 * @return {number}
 */
LRUCache.prototype.get = function (key) {
    if (this.cache.has(key)) {
        var val = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, val);
        return val;
    } else {
        return -1;
    }
};

/** 
 * @param {number} key 
 * @param {number} value
 * @return {void}
 */
LRUCache.prototype.put = function (key, value) {
    if (this.cache.size < this.capacity && !this.cache.has(key)) {
        this.cache.set(key, value);
    } else if (this.cache.has(key)) {
        this.cache.delete(key);
        this.cache.set(key, value);
    } else if (this.cache.size === this.capacity) {
        // Map.prototype.keys() 返回一个迭代对象，而不是数组
        // 迭代对象 Iterator.next() 是迭代对象的第一个对象，而不是值，需要 .value获取值
        this.cache.delete(this.cache.keys().next().value);
        this.cache.set(key, value);
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * var obj = new LRUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */

/**
 * @param {number} capacity
 */
const LRUCache = function (capacity) {
    this.size = 0;
    this.capacity = capacity;
    this.LL = new DoublyLinkedList();
    this.cache = {};
};

LRUCache.prototype.get = function (key) {
    const getNode = this.cache[key];
    if (getNode) {
        this.LL.moveToHead(getNode);
    } else {
        return -1;
    }
    return getNode.val;
};

LRUCache.prototype.put = function (key, value) {
    // overwrite the value if it exists
    if (this.cache[key]) {
        this.cache[key].val = value;
        this.LL.moveToHead(this.cache[key]);
        return;
    }

    // otherwise create new node
    const node = new Node(key, value);

    // only evict if max capacity has been reached
    if (this.size < this.capacity) {
        this.size++;
    } else {
        const keyToRemove = this.LL.removeTail();
        delete this.cache[keyToRemove];
    }

    // set to most recently used
    this.LL.insertHead(node);
    this.cache[key] = node;
};

class Node {
    constructor(key, val) {
        this.key = key;
        this.val = val;
        this.next = null;
        this.prev = null;
    }
}

class DoublyLinkedList {
    constructor() {
        this.head = null;
        this.tail = null;
    }

    removeTail() {
        const evict = this.tail;
        if (evict.prev !== null && this.tail != this.head) {
            evict.prev.next = null;
            this.tail = evict.prev;
        } else {
            this.tail = null;
            this.head = null;
        }
        return evict.key;
    }

    insertHead(node) {
        if (this.head !== null) {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        } else {
            this.head = node;
            this.tail = node;
        }
    }

    moveToHead(node) {
        if (node === this.head) return;
        if (node === this.tail) {
            node.next = this.head;
            this.head.prev = node;
            this.tail = node.prev;
            node.prev.next = null;
            node.prev = null;
        } else {
            node.prev.next = node.next;
            node.next.prev = node.prev;
            node.next = this.head;
            node.next.prev = node;
            node.prev = null
        }
        this.head = node;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * var obj = new LRUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */

LeetCode 题目总结