[leetcode]146. LRU CacheLRU缓存

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;
         }
     }
 }