《算法通关村—LRU的设计与实现》

我们来看一道算法题  LeetCode146：

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。

要求：

实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

        关于什么是LRU，简单来说就是 当内存空间满了，不得不淘汰某些数据时（通常是容量已满），选择最久未被使用的数据进行淘汰。
题目让我们实现一个容量固定的 LRUCache 。如果插入数据时，发现容器已满，则先按照 LRU 规则淘汰一个数据，再将新数据插入，其中「插入」和「查询」都算作一次“使用”。

图示：

首先，依次插入元素1，2，3 。插入元素4的时候容量已满，此时元素1是最久为使用，于是将其删除。接着，查找元素3，3成为最近使用的元素因此被添加到顶部。后续元素的操作以此类推。

实现：

目前公认最合理的方式是使用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）标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。

执行流程：

        首先对元素1执行的put操作， 因为1在hash表中不存在，所以会创建一个新节点newNode包含了key和value。然后在hash表里存放的是key和对应的newNode地址值。最后将该元素添加到双链表的头部。如果此时容量已满，则将tail节点的前一个元素删除。其它元素的添加亦是如此。

        然后是对元素3的get操作，由于3已存在，所以我们将其移动到头部，并返回其对应节点的value即可。

代码如下：

public class LRUCache {
    class DLinkedNode {
        int key; //用于根据返回节点的key删除hash表中的key
        int value;
        DLinkedNode prev;
        DLinkedNode next;

        public DLinkedNode() {
        }

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

    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    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;
    }
}