算法通关村第五关—LRU的设计与实现(黄金)

         LRU的设计与实现

一、理解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]]
输出
[nu1l,nu1l,nu11,1,nu1l,-1,nu1,-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)是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。该算法的思路是，发生缺页中断时，选择未使用时间最长的页面置换出去。假设内存只能容纳3个页大小，按照7 0 1 2 0 3 0 4的次序访问页。假设内存按照栈的方式来描述访问时间，在上面的，是最近访问的，在下面的是，最远时间访问的，LRU就是这样工作的：

二、hash+双向链表实现LRU

 目前公认最合理的方式是使用ash+双向链表。想不到吧，接下来我们就看看该怎么做。
Hash的作用是用来做到O(1)访问元素，哈希表就是普通的哈希映射(HashMap)，通过缓存数据的键映射到其在双向链表中的位置。Hash里的数据是key-value结构。value就是我们自己封装的node,key则是键值，也就是在Hash的地址。
 双向链表用来实现根据访问情况对元素进行排序。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
这样以来，我们要确认元素的位置直接访问哈希表就行了，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在O(1)的时间内完成get或者put操作。具体的方法如下：
1.对于get操作，首先判断key是否存在：
(1)如果key不存在，则返回-1；
(2)如果key存在，则key对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。
2.对于put操作，首先判断key是否存在：
(1)如果key不存在，使用key和value创建一个新的节点，在双向链表的头部添加该节点，并将key和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；
(2)如果key存在，则与get操作类似，先通过哈希表定位，再将对应的节点的值更新为value,并将该节点移到双向链表的头部。
 上述各项操作中，访问哈希表的时间复杂度为O(1),在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为O(1)。而将一个节点移到双向链表的头部，可以分成[删除该节点]和[在双向链表的头部添加节点]两步操作，都可以在O(1)时间内完成。
 同时为了方便操作，在双向链表的实现中，使用一个伪头部(dummy head)和伪尾部(dummy tail)标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。
 来看一个容量为3的例子，首先缓存了1，此时结构如图所示。之后再缓存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(),在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为O()。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在O(1)时间内完成。

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<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;
    }
}

测试类

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
}