算法菜鸟提升日记-01（实现LRU）

从今天开始记录每天的Study，提升！！！
不习惯于记录，太久没有看过就容易忘记，宝贵经验丢失，太可惜了，记录对程序员来说太重要了

关键思路：

1. 要让get()和put()操作时间复杂度为O(1)，考虑到使用Map
2. 用双链表方便删除，map用来查找，完美
3. 删除和插入，需要同步map和链表
4. 使用过的，重新放置头部
5. 容量满了，移除尾端

class LRUCache {
    Map<Integer,Node> cache = new HashMap<>();
    private int capacity;
    private Node head = new Node();
    private Node tail = new Node();
    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if(!cache.containsKey(key)) return -1;
        Node node = cache.get(key);
        
        romeve(node);
        addFirst(node);
        cache.put(key,node);
        return node.val;
    }
    
    public void put(int key, int value) {
        Node newNode = new Node(key,value);
        if(cache.containsKey(key)){
            romeve(cache.get(key));
            addFirst(newNode);
            cache.put(key,newNode);
        }else{
            if(cache.size() == capacity){
                romeveLast();
            }
            addFirst(newNode);
            cache.put(key,newNode);
        }
        
    }

    private void romeve(Node node){
        cache.remove(node.key);

        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    private void romeveLast(){
        if(head == tail) return;
        romeve(tail.prev);
    }
    private void addFirst(Node node){
        node.next = head.next;
        node.prev = head;

        node.next.prev = node;
        head.next = node;
    }
}
class Node{
    int key;
    int val;
    Node prev;
    Node next;
    Node(){}
    Node(int key,int val){
        this.key = key;
        this.val = val;
    }
}
/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */