链表----14.LRU缓存

题目链接 

/**

    需求分析:

            当达到容量上限时 淘汰最久未访问的元素 ---> 双向链表;头节点:最近访问的元素 尾节点:最久未访问的元素

            get put 时间复杂度均为O(1) ---> 哈希表

            两需求同时满足: 哈希表 + 双向链表

            即 双向链表维护各元素访问顺序,哈希表存储双向链表中的节点 两者搭配使用即可满足需求

    执行流程:

            添加元素:若未达到上限 将元素添加到双向链表头节点,以及哈希表中即可

                    若达到上限 定位到最久未访问的元素(双向链表尾节点)删除再添加即可 O(1)

            访问元素:利用哈希表直接访问O(1) 再将元素移动到头节点即可

            操作双向链表中节点时间复杂度也是O(1)的关键: 哈希表中直接存储链表中节点 先在hash表中直接定位到元素O(1) 再操作即可

    功能函数:

            添加元素到头节点

            删除指定节点

            移动节点到头部(先删除再重新添加)

    */

class LRUCache {
    /**
    需求分析: 
            当达到容量上限时 淘汰最久未访问的元素 ---> 双向链表;头节点:最近访问的元素 尾节点:最久未访问的元素
            get put 时间复杂度均为O(1) ---> 哈希表

            两需求同时满足: 哈希表 + 双向链表
            即 双向链表维护各元素访问顺序,哈希表存储双向链表中的节点 两者搭配使用即可满足需求

    执行流程:
            添加元素:若未达到上限 将元素添加到双向链表头节点,以及哈希表中即可
                    若达到上限 定位到最久未访问的元素(双向链表尾节点)删除再添加即可 O(1)
            访问元素:利用哈希表直接访问O(1) 再将元素移动到头节点即可

            操作双向链表中节点时间复杂度也是O(1)的关键: 哈希表中直接存储链表中节点 先在hash表中直接定位到元素O(1) 再操作即可

    功能函数:
            添加元素到头节点
            删除指定节点
            移动节点到头部(先删除再重新添加)
    */

    //定义双向链表
    public static class DLinkedNode {
        int key,value; //相较于传统链表 该场景下需要额外维护key
        DLinkedNode prev,next; 

         DLinkedNode() {};

        DLinkedNode(int key, int value) {
            this.key = key;
            this.value = value;
        }

        DLinkedNode(int key, int value, DLinkedNode prev, DLinkedNode next) {
            this.key = key;
            this.value = value;
            this.prev = prev;
            this.next = next;
        }

    }

    //哈希表
    private Map<Integer,DLinkedNode> cache = new HashMap<>();
    //最大容量
    private final int capacity;
    //当前大小
    private int size;
    //虚拟头节点 
    private  DLinkedNode dummyHead = new DLinkedNode();
    //虚拟尾节点
    private  DLinkedNode dummyTail = new DLinkedNode();

    //添加元素到头节点
    private void addToHead(DLinkedNode node) {
        //将node初步插入到头节点
        node.prev = dummyHead;
        node.next = dummyHead.next;

        //建立node前后的联系
        dummyHead.next.prev = node;
        dummyHead.next = node;
    }

    //删除指定节点
    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //移动节点至头部(先删除 再插入到头节点)
    private void moveTohead(DLinkedNode node) {
        removeNode(node);
        addToHead(node);
    }
    

    //初始化容量与虚拟节点
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;

        //初始化虚拟节点
        dummyHead.next = dummyTail;
        dummyTail.prev = dummyHead;
        
    }
    
    public int get(int key) {
        //从哈希表中读取元素 再移动至首位
        if(cache.get(key) == null) {
            return -1;
        }

        DLinkedNode node = cache.get(key);
        moveTohead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        //DLinkedNode node = new DLinkedNode(key,value);  如果关键字 key 已经存在，则变更其数据值 value
         DLinkedNode node = cache.get(key);
         if(node != null) {
            node.value = value;
            moveTohead(node);
            return;
         }

        node = new DLinkedNode(key,value);
        //先判断当前存储元素个数 若达到上限则先删除尾节点 再添加
        if(size >= capacity) {
            //删除尾节点
            DLinkedNode Tail = dummyTail.prev;
            removeNode(Tail);
            cache.remove(Tail.key);
            size--;
        }
        addToHead(node);
        cache.put(key,node);
        size++;
    }
}

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