LRU的设计与实现-算法通关村

缓存是应用软件的必备功能之一，在操作系统，Java里的Spring、mybatis、redis、mysql等软件中都有自己的内部缓存模块，而缓存是如何实现的呢？在操作系统教科书里我们知道常用的有FIFO、LRU和LFU三种基本的方式。FIFO也就是队列方式不能很好利用程序局部性特征，缓存效果比较差，一般使用**LRU（最近最少使用）**和LFU（最不经常使用淘汰算法）比较多一些。LRU是淘汰最长时间没有被使用的页面，而LFU是淘汰一段时间内，使用次数最少的页面。

1LRU的含义

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)` 的平均时间复杂度运行。
输入： [“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）是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。
该算法的思路是，发生缺页中断时，选择未使用时间最长的页面置换出去。假设内存只能容纳3个页大小，按照 70120304的次序访问页。假设内存按照栈的方式来描述访问时间，在上面的，是最近访问的，在下面的是，最远时间访问的，LRU就是这样工作的：

2 hash + 双向链表实现LRU

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），在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 0（1）。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O（1）时间内完成。
  同时为了方便操作，在双向链表的实现中，使用一个伪头部（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）时间内完成。

  public class LRUCache {
      public static void main(String[] args) {
          LRUCache lruCache = new LRUCache(2);
          lruCache.put(1, 1);//缓存是{1=1}
          lruCache.put(2, 2);//缓存是{2=2，1=1}
          System.out.println(lruCache.get(1));//返回1，缓存是{1=1，2=2}
          lruCache.put(3, 3);//使关键字2作废，缓存是{3=3，1=1}
          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
      }
  
      class DLinkedNode{
          int key;
          int value;
          DLinkedNode prev;
          DLinkedNode next;
  
          public DLinkedNode(){
  
          }
  
          public DLinkedNode(int key, int value){
              this.key = key;
              this.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 = null;
          tail.prev = head;
      }
  
      public int get(int key){
          DLinkedNode node = cache.get(key);
          //如果 key 存在，先通过哈希表定位，再移到头部
          if(node != null){
              moveToHead(node);
              return node.value;
          }else{
              return -1;
          }
      }
  
      public void put(int key, int value){
          DLinkedNode node = cache.get(key);
          //如果，key 不存在，创建一个新的节点
          if(node == null){
              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 removeNode(DLinkedNode node){
          node.prev.next = node.next;
          node.next.prev = node.prev;
      }
      
      private void addToHead(DLinkedNode node){
          node.prev = head;
          node.next = head.next;
          head.next.prev = node;
          head.next = node;
      }
      
      private void moveToHead(DLinkedNode node){
          removeNode(node);
          addToHead(node);
      }
      
      private DLinkedNode removeTail(){
          DLinkedNode res = tail.prev;
          removeNode(res);
          return res;
      }
  }