LeetCode 146. LRU Cache

原题链接在这里：https://leetcode.com/problems/lru-cache/

题目：

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.

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.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LRUCache cache = new LRUCache( 2 /* capacity */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // returns 1
cache.put(3, 3);    // evicts key 2
cache.get(2);       // returns -1 (not found)
cache.put(4, 4);    // evicts key 1
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

题解：

可以通过HashMap 和 Double LinkedList来完成。每个key, value用一个Node 来储存，按照添加顺序一个一个放在list 的head后面。同时把<key, node>放在HashMap中。

get时看HashMap中是否有这个key, 有的话就找到对应的node, 在node里取出对应的value. 同时更新该node 在list中的位置。

set时分三种情况：1. 看HashMap中是否有这个key, 有的话说明本来就有这个key对应的node, 只需要把原有node的value更改并且更新该node 在list中位置即可。

2. HashMap中没有这个key, 同时HashMap的size未达到capacity, 那么新建一个node, 加入HashMap 和 list中即可。

3. HashMap中没有这个key, 同时HashMap的size已经等于capacity, 多加就要溢出，所以按照2中完成添加后要从HashMap 和 list中都去掉最老的node.

Time Complexity: get, O(1). put O(1).

Space: O(n).

AC Java:

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

class LRUCache {
    Node head;
    Node tail;
    Map<Integer, Node> hm;
    int capacity;    

    public LRUCache(int capacity) {
        head = new Node(-1, -1);
        tail = new Node(1, 1);
        head.next = tail;
        tail.prev = head;
        this.capacity = capacity;
        hm = new HashMap<>();
    }
    
    public int get(int key) {
        if(!hm.containsKey(key)){
            return -1;
        }

        Node target = hm.get(key);
        putToHead(target);
        return target.val;
    }
    
    public void put(int key, int value) {
        if(hm.containsKey(key)){
            Node cur = hm.get(key);
            cur.val = value;
            putToHead(cur);
            return;
        }

        if(hm.size() >= capacity){
            int lastKey = removeOldest();
            hm.remove(lastKey);
        }

        Node addedNode = new Node(key, value);
        hm.put(key, addedNode);
        putToHead(addedNode);
    }

    private void putToHead(Node cur){
        if(cur.prev != null && cur.next != null){
            cur.prev.next = cur.next;
            cur.next.prev = cur.prev;
        }

        cur.next = head.next;
        cur.prev = head;
        head.next.prev = cur;
        head.next = cur;
    }

    private int removeOldest(){
        Node lastNode = tail.prev;
        lastNode.prev.next = lastNode.next;
        lastNode.next.prev = lastNode.prev;
        return lastNode.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, 这种数据结构本身已经把HashMap按照添加顺序放好了。

可以参见这个网页：http://www.tutorialspoint.com/java/java_linkedhashmap_class.htm 

所以实现起来很简洁，get时需要更新位置，更新位置是通过删掉旧的，复制一下加回去。

set时参照上面的三种情况即可。

AC Java:

import java.util.LinkedHashMap;
public class LRUCache {
    LinkedHashMap<Integer, Integer> linkedHM;
    int capacity;
    public LRUCache(int capacity) {
        linkedHM = new LinkedHashMap<Integer, Integer>();
        this.capacity = capacity;
    }
    
    public int get(int key) {
        if(linkedHM.containsKey(key)){
            int val = linkedHM.get(key);
            linkedHM.remove(key);
            linkedHM.put(key,val);
            return val;
        }
        return -1;
    }
    
    public void set(int key, int value) {
        if(linkedHM.containsKey(key)){
            linkedHM.remove(key);
            linkedHM.put(key,value);
        }else if(linkedHM.size() < capacity){
            linkedHM.put(key,value);
        }else{
            int oldKey = linkedHM.keySet().iterator().next();
            linkedHM.remove(oldKey);
            linkedHM.put(key,value);
        }
    }
}