LRU Cache 解答

Question

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

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(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.

Solution

My first thought is to use a linked list and a hashmap. But remove and add element for linked list is O(n) per step.

So, the final idea is to implement a bi-directional linked list.

details

For this question, I submitted over 10 times and finally got accepted.

There are many details we need to check.

1. When deleting a node, we should modify both prev and next attributes of its neighbors.

2. Every time when we add a new node, we should check whether it is the first node.

3. When input capacity is 1, we should deal with it separately.

 // Construct double list node
 class Node {
     public Node prev;
     public Node next;
     private int val;
     private int key;
     public Node(int key, int val) {
         this.key = key;
         this.val = val;
     }
     public void setValue(int val) {
         this.val = val;
     }
     public int getKey() {
         return key;
     }
     public int getValue() {
         return val;
     }
 }

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

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

     private void moveToHead(Node target) {
         // Check whether target is already at head
         if (target.prev == null)
             return;
         // Check whether target is at tail
         if (target == tail)
             tail = target.prev;
         Node prev = target.prev;
         Node next = target.next;
         if (prev != null)
         prev.next = next;
         if (next != null)
             next.prev = prev;

         Node oldHead = head;
         target.prev = null;
         target.next = oldHead;
         oldHead.prev = target;
         head = target;
     }

     public int get(int key) {
         if (!map.containsKey(key))
             return -1;
         Node current = map.get(key);
         // Move found node to head
         moveToHead(current);
         return current.getValue();
     }

     public void set(int key, int value) {
         if (map.containsKey(key)) {
             Node current = map.get(key);
             current.setValue(value);
             // Move found node to head
             moveToHead(current);

         } else {
             Node current = new Node(key, value);
             // Add new node to map
             map.put(key, current);

             // Check whether map size is bigger than capacity
             if (map.size() > capacity) {
                 // Move farest used element out
                 Node last = tail;
                 map.remove(last.getKey());
                 // Remove from list
                 if (map.size() == 1) {
                     head = current;
                     tail = current;
                 } else {
                     Node oldHead = head;
                     current.next = oldHead;
                     oldHead.prev = current;
                     head = current;
                     tail = tail.prev;
                     tail.next = null;
                 }

             } else {
                 // Add new node to list
                 if (map.size() == 1) {
                     head = current;
                     tail = current;
                 } else {
                     Node oldHead = head;
                     current.next = oldHead;
                     oldHead.prev = current;
                     head = current;
                 }
             }
         }
     }
 }