146. LRU Cache

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.

class DLL{
    DLL pre;
    DLL next;
    int val;
    int key;
    public DLL(int key,int val){
        pre=null;
        next=null;
        this.key = key;
        this.val = val;
    }
}
public class LRUCache {
    private int capacity;
    private HashMap<Integer,DLL> map;
    private DLL head, tail;
    
    public LRUCache(int capacity) {
        map = new HashMap<>();
        this.capacity = capacity;
        head = new DLL(0,0);
        tail = new DLL(0,0);
        //be careful the meaning of next and pre
        head.next = tail; 
        tail.pre = head;
    }
    
    public int get(int key) {
        int val = -1;
        if(map.containsKey(key)){
            DLL node = map.get(key);
            val = node.val;
            //put the node map.get(key) to head
            refresh(node);
        }
        return val;
    }
    
    public void set(int key, int value) {
        if(map.containsKey(key)){
            DLL node = map.get(key);
            node.val = value;
            //reorder DDL(key) to head
            refresh(node);
        }else{
            DLL node = null;
            //THIS IS THE MOST DIFFICULT PART
            if(this.capacity<=map.size()){
                //get the last node, reuse it
                node = tail.pre;
                //remove the last node from hashmap
                map.remove(node.key);
                //change the key,val of the last node, reuse it
                node.val = value;
                node.key = key;
                //remove it from tail: cut the links
                remove(node);
            }else{
                //create a new node
                node = new DLL(key,value);
            }
            //add to hashmap. first check map.size then put new key pair to map.
            map.put(key,node);
            //insert to head
            insert(node);
        }
    }
    private void refresh(DLL node){
        remove(node);
        insert(node);
    }
    private void insert(DLL node){
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
    }
    private void remove(DLL node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
}