[leetcode]146. LRU Cache实现LRU缓存

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?

题意：实现一个LRU缓存

Solution: HashMap + doubly LinkedList

删除操作分为2种情况：

• 给定node data删除node: 单链表和双向链表都需要从头到尾进行遍历从而找到对应node进行删除，时间复杂度都为O(n)。
• 给定node address删除node: 单链表需要从头到尾遍历直到找到该node的pre node，时间复杂度为O(n)。双向链表只需O(1)时间即能找到该node的pre node。

HashMap保存node address，可以基本保证在O(1)时间内找到该node

具体实现如下：

put(1,1):   先create 一个newNode(1,1)地址为$Node@435，HashMap存入(1, $Node@435),  双向链表将newNode(1,1)设为head

 put(2,2):   先create 一个newNode(2,2)地址为$Node@436，HashMap存入(2, $Node@436),  双向链表将newNode(2,2)设为head

 get(1):   先在HashMap中找到1对应node的地址$Node@435，通过该地址找到双向链表对应node(1,1) 。删除该node(1,1)再重新setHead

 

put(3,3):   先create 一个newNode(3,3)地址为$Node@437, 发现Cache is full! We need to evict something to make room.

            1.　　首先释放HashMap空间，通过双向链表中tailNode的key找到要在HashMap中删除的key

         

             2.　　然后删掉双向链表的tailNode

            3.　　将newNode(3,3)在双向链表中setHead

思考：

1. why not using java.util.LinkedinList? 

因为java自带的linkedlist中，删除操作是从头到尾scan特定值再删除，时间为O(n)。但题目要求O(1)。

2. why not using java.util.LinkedHashMap?
这题说白了，就是考察java自带的LinkedHashMap是怎么实现的，我们当然不能。

code

public class LRUCache {
    private int capacity;
    private final HashMap<Integer, Node> map;
    private Node head;
    private Node tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>();
    }

    public int get(int key) {
        // no key exists
        if (!map.containsKey(key)) return -1;
        // key exists, move it to the front
        Node n = map.get(key);
        remove(n);
        setHead(n);
        return n.value;

    }

    public void put(int key, int value) {
        // key exits
        if (map.containsKey(key)) {
            // update the value
            Node old = map.get(key);
            old.value = value;
            // move it to the front
            remove(old);
            setHead(old);
        }
        // no key exists
        else {
            Node created = new Node(key, value);
            // reach the capacity, move the oldest item
            if (map.size() >= capacity) {
                map.remove(tail.key);
                remove(tail);
                setHead(created);
            }
            // insert the entry into list and update mapping
            else {
                setHead(created);
            }
            map.put(key, created);
        }
    }

    private void remove(Node n) {
        if (n.prev != null) {
            n.prev.next = n.next;
        } else {
            head = n.next;
        }
        if (n.next != null) {
            n.next.prev = n.prev;
        } else {
            tail = n.prev;
        }

    }

    private void setHead(Node n) {
        n.next = head;
        n.prev = null;
        if (head != null) head.prev = n;
        head = n;
        if (tail == null) tail = head;
    }

    // doubly linked list
    class Node {
        int key;
        int value;
        Node prev;
        Node next;

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