146. LRU 缓存机制

146. LRU 缓存机制

class LRUCache {
    public class DoubleListNode{
        private int key;
        private int value;
        DoubleListNode prev;
        DoubleListNode next;
        public DoubleListNode(){};
        public DoubleListNode(int key,int value){
            this.key = key;
            this.value = value;
        }
    }
    
    private Map<Integer,DoubleListNode> cache = new HashMap<>();
    private int capacity;
    private int size;
    private DoubleListNode head,tail;
    
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new DoubleListNode();
        tail = new DoubleListNode();
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if(cache.get(key) != null){
            DoubleListNode node = cache.get(key);
            moveToHead(node);
            return node.value;            
        }else return -1;
    }
    
    public void put(int key, int value) {
        if(cache.get(key) == null){
            size++;
            if(size > capacity){
                cache.remove(removeTail().key);
                size--;   
            }
            DoubleListNode node = new DoubleListNode(key,value);
            cache.put(key,node);
            addToHead(node);
        }else{
            DoubleListNode node = cache.get(key);
            node.value = value;
            moveToHead(node);
        }
        
    }
    private void removeNode(DoubleListNode node){
        node.next.prev = node.prev;
        node.prev.next = node.next;
    }
    private void addToHead(DoubleListNode node){
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }
    private void moveToHead(DoubleListNode node){
        removeNode(node);
        addToHead(node);
    }
    private DoubleListNode removeTail(){
        DoubleListNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

/**
 * 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);
 */

用双向链表储存顺序，可以完成O(1)的移位操作，然后hashmap记录key，node键值对