力扣 146.LRU缓存 （最简单直观解法）

题目介绍

题解

需要实现LRUCache方法、get方法、put方法

自定义方法：remove和pushFront

• remove只删除节点，不执行map删除操作
• addFront只在头哑结点后面添加新节点，不执行map添加操作
  代码如下：

class LRUCache {
    // 定义了一个双向链表节点类
    class DLinkedNode {
        int key, value;
        DLinkedNode prev, next;

        public DLinkedNode(int k, int v) { // 构造器：初始化键值对，前后指针默认为 null
            key = k;
            value = v;
        }
    }

    int capacity;
    DLinkedNode dummy = new DLinkedNode(0, 0); // 哨兵节点
    Map<Integer, DLinkedNode> map = new HashMap<>();//键为key，值为双向链表节点包括key value以及前后指针

    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.prev = dummy;
        dummy.next = dummy;
    }

    // 删除一个节点
    private void remove(DLinkedNode x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
    }

    // 在链表头哑节点后添加一个新节点
    private void addFront(DLinkedNode x) {
        x.prev = dummy;
        x.next = dummy.next;
        x.prev.next = x;
        x.next.prev = x;
    }

    public int get(int key) {
        DLinkedNode node = map.get(key);
        if (node == null) {
            return -1;
        } else {
            remove(node); // 注意要先remove掉，否则原来的连接不会断开
            addFront(node);
            return node.value;
        }
    }

    public void put(int key, int value) {
        DLinkedNode node = map.get(key); //根据 key 获取对应的节点,node可能为空
        if (node != null) { 
            node.value = value; // 更新 value
            remove(node);
            addFront(node);
        } else {  // node为空
            node = new DLinkedNode(key, value); 
            map.put(key, node);
            addFront(node); // 放在最上面
            if (map.size() > capacity) { // 书太多了去掉最后一本书
                map.remove(dummy.prev.key);// 注意要先从map里删除，要是先remove的话链表就断开了
                remove(dummy.prev); 
            }
        }
    }
}



灵茶山：
class LRUCache {
    // 定义了一个双向链表节点类
    class DLinkedNode {
        int key, value;
        DLinkedNode prev, next;

        DLinkedNode(int k, int v) { // 构造器：初始化键值对，前后指针默认为 null
            key = k;
            value = v;
        }
    }

    int capacity;
    DLinkedNode dummy = new DLinkedNode(0, 0); // 哨兵节点
    Map<Integer, DLinkedNode> map = new HashMap<>();//键为key，值为双向链表节点包括key value以及前后指针

    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.prev = dummy;
        dummy.next = dummy;
    }
   
    // 删除一个节点
    private void remove(DLinkedNode x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
    }

    // 在链表头添加一个节点
    private void pushFront(DLinkedNode x) {
        x.prev = dummy;
        x.next = dummy.next;
        x.prev.next = x;
        x.next.prev = x;
    }
    
    //根据 key 获取对应的节点，如果该节点存在就把该节点移到链表头部并返回该节点，如果不存在则返回null
    private DLinkedNode getNode(int key) {
        DLinkedNode node = map.get(key); 
        if (node == null) {  // 如果没有这本书
            return null;
        } else {   // 有这本书
            remove(node); // 把这本书移除
            pushFront(node); // 放在最上面
            return node;
        }
    }

    public int get(int key) {
        DLinkedNode node = getNode(key);
        return node != null ? node.value : -1;
    }

    public void put(int key, int value) {
        DLinkedNode node = getNode(key); //根据 key 获取对应的节点，如果该节点存在就把该节点移到链表头部并返回该节点，如果不存在则返回null
        if (node != null) { // 有这本书
            node.value = value; // 更新 value
        }else{
            node = new DLinkedNode(key, value); // 新书
            map.put(key, node);
            pushFront(node); // 放在最上面
            if (map.size() > capacity) { // 书太多了
                DLinkedNode backNode = dummy.prev;
                map.remove(backNode.key);
                remove(backNode); // 去掉最后一本书
            }
        }
    }
}

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