LeetCode刷题—LRU缓存机制

146，LRU缓存机制，medium

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。

实现 LRUCache 类：

• LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存

• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。

• void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

题解

LRU 缓存淘汰算法是一种常用策略，认为最近使用的数据是「有用的」，很久没用过的数据是「没用的」，当内存满了就优先删除没用的数据。

此题需要设计数据结构，首先接收一个 capacity 参数作为缓存的最大容量，然后实现两个 API，一个是 put(key, val) 方法存入键值对，另一个是 get(key) 方法获取 key 对应的 val，如果 key 不存在则返回 -1。

此数据结构的必要条件： 1. cache 中的元素必须有时序，区分最近使用和久未使用的数据。 2. API 需要快速查找，快速插入，快速删除。

哈希表能实现快速查找，但无固定顺序。链表有顺序，能实现快速插入和删除，但查找慢。结合一下就形成新的数据结构：哈希链表 LinkedHashMap 。

• 双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

• 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。

这样一来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1) 的时间内完成 get 或者 put 操作。具体的方法如下：

• 对于 get 操作，首先判断 key 是否存在：
  • 如果 key 不存在，则返回−1；
  • 如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。
• 对于 put 操作，首先判断 key 是否存在：
  • 如果 key 不存在，使用 key 和 value 创建一个新的节点，在双向链表的头部添加该节点，并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；
  • 如果 key 存在，则与 get 操作类似，先通过哈希表定位，再将对应的节点的值更新为 value，并将该节点移到双向链表的头部。

为什么要用双向链表不用单向链表呢？下面通过代码思考。

双链表的节点类：

class Node{
    int key;
    int value;
    Node prev;
    Node next;
    public Node(int k, int v){
        this.key = k;
        this.value = v;
    }
}

然后依靠 Node 类型构建一个双向链表，实现几个LRU算法需要的API：

class DoubleList{
    //头尾虚拟节点
    Node head;
    Node tail;
    //元素数量
    int size;
    
    public DoubleList(){
        //初始化双向链表
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next = tail;
        tail.next = head;
        size = 0;
    }
    //添加节点到头部
    private void addToHead(Node node){
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
        size++;
    }
    //删除节点
    private void removeNode(Node node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }
    //将节点移至头部
    private void moveToHead(Node node){
        removeNode(node);
        addToHead(node);
    }
    //删除链表中最后一个节点，并返回该节点
    private Node removeTail(){
        Node res = tail.prev;
        removeNode(res);
        return res;
    }
    public int size(){
        return size;
    }
}

到这里就能回答刚才「为什么必须要用双向链表」的问题了，因为我们需要删除操作。删除一个节点不光要得到该节点本身的指针，也需要操作其前驱节点的指针，而双向链表才能支持直接查找前驱，保证操作的时间复杂度 O(1)。

有了双向链表，只需要在LRU算法中把它和哈希表结合起来即可。代码框架：

class LRUCahche{
    private HashMap<Integer, Node> map;
    private DoubleList cache;
    private int capacity;
    
    public LRUCache(int capacity){
        this.capacity = capacity;
        map = new HashMap<>();
        cache = new DoubleList();
    }

下面就能实现LRU算法的 get 和 put 方法。在维护链表的同时也要注意 map 中元素的增加、删除。

get 操作较简单：若不存在 key，返回 -1；若存在，将链表中对应节点提至链表头部，再返回对应的value 值。

put 操作较复杂，通过一个流程图来梳理：

到此为止整个算法流程就梳理完了，还有一个问题要思考： 既然哈希表中已经存了 key，为什么链表中还要存 key 和 val 呢，只存 val 不就行了？

代码

class LRUCache {
    class Node{
        int key;
        int value;
        Node prev;
        Node next;
        public Node(int k, int v){
        this.key = k;
        this.value = v;
        }
    }
    class DoubleList{
        //头尾虚拟节点
        Node head;
        Node tail;
        //元素数量
        int size;
    
        public DoubleList(){
            //初始化双向链表
            head = new Node(0,0);
            tail = new Node(0,0);
            head.next = tail;
            tail.next = head;
            size = 0;
        }
        //添加节点到头部
        private void addToHead(Node node){
            node.prev = head;
            node.next = head.next;
            head.next.prev = node;
            head.next = node;
            size++;
        }
        //删除节点
        private void removeNode(Node node){
            node.prev.next = node.next;
            node.next.prev = node.prev;
            size--;
        }
        //将节点移至头部
        private void moveToHead(Node node){
            removeNode(node);
            addToHead(node);
        }
        //删除链表中最后一个节点，并返回该节点
        private Node removeTail(){
            Node res = tail.prev;
            removeNode(res);
            return res;
        }
        public int size(){
            return size;
        }
    }
    private HashMap<Integer, Node> map;
    private DoubleList cache;
    private int capacity;
    
    public LRUCache(int capacity){
        this.capacity = capacity;
        map = new HashMap<>();
        cache = new DoubleList();
    }
    
    public int get(int key) {
        if(!map.containsKey(key)) return -1;
        Node n = map.get(key);
        //提至头部
        cache.moveToHead(n);
        return n.value;
    }
    
    public void put(int key, int value) {
        Node n = new Node(key, value);
        //若key已存在，修改链表中的值并提至头部，修改map中的键值对
        if(map.containsKey(key)){
            cache.removeNode(map.get(key));
            cache.moveToHead(n);
            map.put(key, n);
        }
        //若key不存在，需要插入n
        else{
            //若容量已满，删除尾部最后一个 和map中对应的键值对
            if(cache.size() == capacity){
                Node node = cache.removeTail();
                map.remove(node.key);
            }
            //向链表头部和map中添加新元素
            cache.addToHead(n);
            map.put(key, n);
        }
    }
}

实现 put 方法，可以回答上面的问题。容量满了要删除最后一个久未使用的元素，同时还要将 map 中对应的键删除。如果链表中只存储 value，那么就无法得知 key，就无法删除 map 中对应的键值对。