Leetcode-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.

Analysis:

Use double linked list.

Solution:

class Node{
    int key;
    int val;
    Node pre;
    Node next;
    public Node(int k, int v){
        key= k;
        val = v;
        pre = null;
        next = null;
    }
}

public class LRUCache {


    Map<Integer,Node> record;
    Node preHead,end;
    int maxCapa;
    int curCapa;
    
    public LRUCache(int capacity) {
        record = new HashMap<Integer,Node>();
        preHead = new Node(-1,-1);
        end = null;
        maxCapa = capacity;
        curCapa = 0;
    }
    
    public int get(int key) {
        if (!record.containsKey(key)) return -1;
        Node cur = record.get(key);
        if (cur==end) return cur.val;

        cur.pre.next = cur.next;
        cur.next.pre = cur.pre;
        end.next = cur;
        cur.next = null;
        cur.pre = end;
        end = cur;        
        return cur.val;
    }
    
    public void set(int key, int value) {
        if (maxCapa==0) return;

        if (record.containsKey(key)){
            Node cur = record.get(key);
            cur.val = value;
            this.get(key);
        } else {
            if (curCapa==maxCapa){
                Node cur = preHead.next;
                preHead.next = cur.next;
                record.remove(cur.key);
                curCapa--;                
            }
 
            curCapa++;
            Node cur = new Node(key,value);
            record.put(key,cur);
            if (curCapa==1){
                preHead.next = cur;
                cur.pre = preHead;
                end = cur;
            } else {
                end.next = cur;
                cur.pre = end;
                end = cur;
            }            
        }
    }
}