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