LRU的设计与实现

关卡名	黄金挑战——LRU的设计与实现	我会了✔️
核心内容	1.理解LRU的原理	✔️
	2.理解LRU是如何实现的	✔️
	3.能够通过代码实现LRU	✔️

缓存是应用软件的必备功能之一，在操作系统，Java里的Spring、mybatis、redis、mysql等软件中都有自己的内部缓存模块，而缓存是如何实现的呢？在操作系统教科书里我们知道常用的有FIFO、LRU和LFU三种基本的方式。FIFO也就是队列方式不能很好利用程序局部性特征，缓存效果比较差，一般使用LRU（最近最少使用）和LFU(最不经常使用淘汰算法)比较多一些。LRU是淘汰最长时间没有被使用的页面，而LFU是淘汰一段时间内，使用次数最少的页面。
从实现上LRU是相对容易的，而LFU比较复杂，我们本章重点研究一下LRU的问题，这也是一道高频题目。LeetCode146：设计一个LRU缓存，这个题也经常见到，在牛客也是长期排名前三：

1 LRU的含义 

先看题意，LeetCode146：运用你所掌握的数据结构，设计和实现一个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，简单来说就是 当内存空间满了，不得不淘汰某些数据时（通常是容量已满），选择最久未被使用的数据进行淘汰。
这里做了简化 ，题目让我们实现一个容量固定的 LRUCache 。如果插入数据时，发现容器已满时，则先按照 LRU 规则淘汰一个数据，再将新数据插入，其中「插入」和「查询」都算作一次“使用”。
看一个百度百科的例子：LRU_百度百科
最近最少使用算法（LRU）是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。
该算法的思路是，发生缺页中断时，选择未使用时间最长的页面置换出去。 假设内存只能容纳3个页大小，按照 7 0 1 2 0 3 0 4 的次序访问页。假设内存按照栈的方式来描述访问时间，在上面的，是最近访问的，在下面的是，最远时间访问的，LRU就是这样工作的：

如果再有其他元素就依次类推。
如果告诉你上述原理，该怎么实现呢？定义一个数组，然后根据上面的规则写吗？估计一小时也写不出来，即使写出来了，也非常容易超时，那该怎么做呢？直接说结论，目前公认最好的方式是使用Hash+双链表。

2 hash+双向链表实现LRU

目前公认最合理的方式是使用hash+双向链表。想不到吧，接下来我们就看看该怎么做。

• Hash的作用是 用来做到O(1)访问元素，哈希表就是普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。Hash里的数据是key-value结构。value就是我们自己封装的node，key则是键值，也就是在Hash的地址。
• 双向链表用来实现根据访问情况对元素进行排序。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

这样以来，我们要确认元素的位置直接访问哈希表就行了，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)的时间内完成 get 或者 put 操作。具体的方法如下：

● 对于 get 操作，首先判断 key 是否存在：

• 如果 key 不存在，则返回 -1；
• 如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。

● 对于 put 操作，首先判断 key 是否存在：

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

上述各项操作中，访问哈希表的时间复杂度为 O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O(1) 时间内完成。
同时为了方便操作，在双向链表的实现中，使用一个伪头部（dummy head）和伪尾部（dummy tail）标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。
看个图示：
在双向链表的实现中，使用一个伪头部（dummy head）和伪尾部（dummy tail）标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。
我们先看容量为3的例子，首先缓存了1，此时结构如图a所示。之后再缓存2和3，结构如b所示。

之后 4再进入， 此时容量已经不够了，只能将最远未使用的元素1删掉， 然后将4插入到链表头部。此时就变成了上图c的样子。
接下来假如又访问了一次2，会怎么样呢？此时会将2移动到链表的首部，也就是下图d的样子。 

 

之后假如又要缓存5呢？此时就将tail指向的3删除，然后将5插入到链表头部。也就是上图e的样子。
上面的方案要实现是非常容易的，我们注意到链表主要执行几个操作：

1. 假如容量没满， 则将新元素直接插入到链表头就行了。
2. 如果容量够了，新的元素到来，则将tail指向的表尾元素删除就行了。
3. 假如要访问已经存在的元素，则此时将该先从链表中删除，再插入到表头就行了。 

再看Hash的操作：

1. Hash没有容量的限制，凡是被访问的元素都会在Hash中有个标记，key就是我们的查询条件，而value就是链表的结点的引用，可以不用访问链表直接定位到某个结点，然后就可以执行我们在上一节提到的方法来删除对应的结点。
2. 这里双向链表的删除好理解，那HashMap中是如何删除的呢？其实就是将node变成为null。这样get(key)的时候返回的是null，就实现了删除的功能。

上述各项操作中，访问哈希表的时间复杂度为 O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O(1)时间内完成。 

import java.util.HashMap;
import java.util.Map;

public class LRUCache {
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;

        public DLinkedNode() {
        }

        public DLinkedNode(int _key, int _value) {
            key = _key;
            value = _value;
        }
    }

    private Map cache = new HashMap();
    private int size;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        moveToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            // 如果 key 不存在，创建一个新的节点
            DLinkedNode newNode = new DLinkedNode(key, value);
            // 添加进哈希表
            cache.put(key, newNode);
            // 添加至双向链表的头部
            addToHead(newNode);
            ++size;
            if (size > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                DLinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                --size;
            }
        } else {
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            node.value = value;
            moveToHead(node);
        }
    }

    private void addToHead(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.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);
    }

    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

再来个测试类：

public static void main(String[] args) {
    LRUCache lRUCache = new LRUCache(2);
    lRUCache.put(1, 1); // 缓存是 {1=1}
    lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
    System.out.println(lRUCache.get(1));    // 返回 1
    lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
    System.out.println(lRUCache.get(2));    // 返回 -1 (未找到)
    lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
    System.out.println(lRUCache.get(1));    // 返回 -1 (未找到)
    System.out.println(lRUCache.get(3));    // 返回 3
    System.out.println(lRUCache.get(4));    // 返回 4
}