设计数据结构-LRU缓存算法

LRU缓存算法

力扣第 146 题「LRU缓存机制」就是让你设计数据结构：

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

get 和 put 方法必须都是 O(1) 的时间复杂度

要让 put 和 get 方法的时间复杂度为 O(1)，我们可以总结出 cache 这个数据结构必要的条件：

• cache 中的元素必须有时序，以区分最近使用的和久未使用的数据，当容量满了之后要删除最久未使用的那个元素腾位置。
• 我们要在 cache 中快速找某个 key 是否已存在并得到对应的 val；
• 每次访问 cache 中的某个 key，需要将这个元素变为最近使用的，也就是说 cache 要支持在任意位置快速插入和删除元素。

哈希表查找快，但是数据无固定顺序；链表有顺序之分，插入删除快，但是查找慢。所以结合一下，形成一种新的数据结构：哈希链表 LinkedHashMap。

LRU 缓存算法的核心数据结构就是哈希链表，双向链表和哈希表的结合体。这个数据结构长这样：

来逐一分析上面的 3 个条件：

• 如果我们每次默认从链表尾部添加元素，那么显然越靠尾部的元素就是最近使用的，越靠头部的元素就是最久未使用的。
• 对于某一个 key，我们可以通过哈希表快速定位到链表中的节点，从而取得对应 val。
• 链表显然是支持在任意位置快速插入和删除的，改改指针就行。只不过传统的链表无法按照索引快速访问某一个位置的元素，而这里借助哈希表，可以通过 key 快速映射到任意一个链表节点，然后进行插入和删除。

这里可以通过hashmap的key来快速找到对应的node节点，所以就能快速的插入删除了。

先自己造轮子实现一遍 LRU 算法#

首先，把双链表的节点类写出来：

class Node {

    public int key, val;

    public Node next, prev;

    public Node(int k, int v) {

    this.key = k;

    this.val = v;

    }

}

然后依靠我们的 Node 类型构建一个双链表，实现几个 LRU 算法必须的 API：

class DoubleList {

    // 头尾虚节点

    private Node head, tail;

    // 链表元素数

    private int size;



    public DoubleList() {

    // 初始化双向链表的数据

    head = new Node(0, 0);

    tail = new Node(0, 0);

    head.next = tail;

    tail.prev = head;

    size = 0;

    }



    // 在链表尾部添加节点 x，时间 O(1)

    public void addLast(Node x) {

    x.prev = tail.prev;

    x.next = tail;

    tail.prev.next = x;

    tail.prev = x;

    size++;

    }



    // 删除链表中的 x 节点（x 一定存在）

    // 由于是双链表且给的是目标 Node 节点，时间 O(1)

    public void remove(Node x) {

    x.prev.next = x.next;

    x.next.prev = x.prev;

    size--;

    }



    // 删除链表中第一个节点，并返回该节点，时间 O(1)

    public Node removeFirst() {

    if (head.next == tail)

      return null;

    Node first = head.next;

    remove(first);

    return first;

    }



    // 返回链表长度，时间 O(1)

    public int size() { return size; }



}

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

有了双向链表的实现，我们只需要在 LRU 算法中把它和哈希表结合起来即可，先搭出代码框架：

class LRUCache {

    // key -> Node(key, val)

    private HashMap<Integer, Node> map;

    // Node(k1, v1) <-> Node(k2, v2)...

    private DoubleList cache;

    // 最大容量

    private int cap;



    public LRUCache(int capacity) {

    this.cap = capacity;

    map = new HashMap<>();

    cache = new DoubleList();

    }

由于我们要同时维护一个双链表 cache 和一个哈希表 map，很容易漏掉一些操作，比如说删除某个 key 时，在 cache 中删除了对应的 Node，但是却忘记在 map 中删除 key。

解决这种问题的有效方法是：在这两种数据结构之上提供一层抽象 API。

尽量让 LRU 的主方法 get 和 put 避免直接操作 map 和 cache 的细节。我们可以先实现下面几个函数：

/* 将某个 key 提升为最近使用的 */

private void makeRecently(int key) {

    Node x = map.get(key);

    // 先从链表中删除这个节点

    cache.remove(x);

    // 重新插到队尾

    cache.addLast(x);

}



/* 添加最近使用的元素 */

private void addRecently(int key, int val) {

    Node x = new Node(key, val);

    // 链表尾部就是最近使用的元素

    cache.addLast(x);

    // 别忘了在 map 中添加 key 的映射

    map.put(key, x);

}



/* 删除某一个 key */

private void deleteKey(int key) {

    Node x = map.get(key);

    // 从链表中删除

    cache.remove(x);

    // 从 map 中删除

    map.remove(key);

}



/* 删除最久未使用的元素 */

private void removeLeastRecently() {

    // 链表头部的第一个元素就是最久未使用的

    Node deletedNode = cache.removeFirst();

    // 同时别忘了从 map 中删除它的 key

    int deletedKey = deletedNode.key;

    map.remove(deletedKey);

}

这里就能回答之前的问答题「为什么要在链表中同时存储 key 和 val，而不是只存储 val」，注意 removeLeastRecently 函数中，我们需要用 deletedNode 得到 deletedKey。

先来实现 LRU 算法的 get 方法：

    public int get(int key) {

        if (!map.containsKey(key)) {

    return -1;

        }

        // 将该数据提升为最近使用的

        makeRecently(key);

        return map.get(key).val;

    }

put 方法稍微复杂一些，我们先来画个图搞清楚它的逻辑：

写出 put 方法的代码：

    public void put(int key, int val) {

        if (map.containsKey(key)) {

    // 删除旧的数据

    deleteKey(key);

    // 新插入的数据为最近使用的数据

    addRecently(key, val);

    return;

        }



        if (cap == cache.size()) {

    // 删除最久未使用的元素

    removeLeastRecently();

        }

        // 添加为最近使用的元素

        addRecently(key, val);

    }

    最后用 Java 的内置类型 `LinkedHashMap` 来实现 LRU 算法，逻辑和之前完全一致：

class LRUCache {

    int cap;

    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();

    public LRUCache(int capacity) { 

    this.cap = capacity;

    }



    public int get(int key) {

    if (!cache.containsKey(key)) {

      return -1;

    }

    // 将 key 变为最近使用

    makeRecently(key);

    return cache.get(key);

    }



    public void put(int key, int val) {

    if (cache.containsKey(key)) {

      // 修改 key 的值

      cache.put(key, val);

      // 将 key 变为最近使用

      makeRecently(key);

      return;

    }



    if (cache.size() >= this.cap) {

      // 链表头部就是最久未使用的 key

      int oldestKey = cache.keySet().iterator().next();

      cache.remove(oldestKey);

    }

    // 将新的 key 添加链表尾部

    cache.put(key, val);

    }



    private void makeRecently(int key) {

    int val = cache.get(key);

    // 删除 key，重新插入到队尾

    cache.remove(key);

    cache.put(key, val);

    }

}