[Leetcode][JAVA] 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.

 

LRU cache, 采用“如果满则淘汰最近未使用的项目“的策略，所以需要一个序列，每次插入的项目放入序列首，被查找的项目也移至序列首。如果超过数量上限则删除序列最后的项目。查找，插入操作都需要O(1)的时间复杂度，否则超时通不过。所以这个序列可以是链表，并且为了查找快捷，需要结合HashMap。由于涉及到转移项目操作，需要双向链表。

HashMap用于把查找键key和具体项目联系起来，这样就能直接获得项目，然后将其移至链表首位。

需要注意的是set操作中，如果set的key已经存在了，那就相当于一次查找操作加上修改其值和HashMap的操作。

代码如下：

class Node
    {
        int key;
        int value;
        Node next;
        Node front;
        Node(int k, int v)
        {
            key=k;
            value=v;
            next=null;
            front=null;
        }
    }
    
    private HashMap<Integer, Node> hs;
    private Node head;
    private Node tail;
    private int cap;
    public LRUCache(int capacity) {
        hs = new HashMap<Integer, Node>();
        head = null;
        cap = capacity;
        tail = null;
    }
    
    public int get(int key) {
        Node re = hs.get(key);
        if(re==null)
            return -1;
        if(re.front==null)
            return re.value;
        re.front.next = re.next;
        if(re.next!=null)
            re.next.front = re.front;
        else
            tail = re.front;
        re.front = null;
        re.next = head;
        head.front = re;
        head = re;
        return re.value;
    }
    
    public void set(int key, int value) {
        Node temp = hs.get(key);
        if(temp!=null)
        {
            get(key);
            head.value = value;
            hs.put(key,head);
        }
        else
        {
            temp = new Node(key, value);
            temp.next = head;
            if(head!=null)
                head.front = temp;
            head = temp;
            if(hs.size()==0)
                tail = temp;
            hs.put(key, temp);
            if(hs.size()>cap)
            {
                hs.remove(tail.key);
                tail.front.next = null;
                tail = tail.front;
            }
        }
    }