LRU缓存内存替换算法：least recently unused 缓存内存替换算法

LRU缓存内存替换算法：least recently unused 缓存内存替换算法

提示：LRU和LFU

我看LRU一直是字节跳动经常面试考的题目，直接让你现场手撕代码，因此本题应该说要大力理解，并学会手撕代码
LRU是完全可以手撕的算法
LFU是可以给面试官讲清楚核心思想，但是只需要填写其中一段代码即可
LRU和LFU是实际系统中的内存替换算法，极其重要的！！！

只有看懂本文，才能知道LFU是怎么实现的：
LFU缓存替换算法：least frequency unused 缓存替换算法

---

题目

请你设计并实现一个满足 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) 的平均时间复杂度运行。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

一、审题

示例：关键在于：如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
举个例子：
咱们按照下面这个顺序操作：
假设：capacity=2
操作：
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}

lRUCache.get(1); // 返回 1

刚刚最新操作的节点是1，所以22就是最近没有被操作的节点，排到head了
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
新来的33把最近未被操作的那个22废了，挤出去了，因为capacity就2而已，不够了缓存，只能替换掉22【这就是LRU缓存替换算法】

lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
11被挤出去了，它是最近未被操作的点

lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
33又成了最新的被操作的，所以排tail，而44排head

lRUCache.get(4); // 返回 4
4又是最新被操作的，排到tail，33没有被操作，又排到head了

---

二、解题

事实上，大家都已经明白了本题，怎么解的了

整个LRU缓存替换算法，里头存的就是一个1维双向链表；
干的就是把双向链表中，最近未被操作的节点，排在head，最近被操作的节点排在tail
我们令双向链表的名字叫NDLL（NodeDoubleLinkList）
LRUCache中有这个NDLL链表，然后又put函数，get函数

注意，LRUCache在put时，如果NDLL容量已经满了，则需要干掉最近未被操作的那个节点，
然后才能放新节点的，因为还得有一个removeMostUnusedCache（）函数

注意，在get时，实际上我们为了o(1)拿到x，则需要用哈希表map，存x对应节点的value，这样就满足了题目的要求
故，内部还得有一个x–value对应的哈希表结构，在删除多余节点的时候要同时删除这个表中的key=x。

另外，对于一个双向链表NDLL来说，
内部都是双向指针的一个节点：

public static class Node<K, V>{
        //泛型，K，V都是不同的数据类型，比如String和Integer啥的，今后在改的时候随时写就行
        //俩属性，一个是key，可以value，封装作为链表的节点
        public K key;
        public V value;
        public Node<K, V> last;//先后指针
        public Node<K, V> next;//先后指针

        public Node(K k, V v){
            key = k;
            value = v;
        }
    }

这个NDLL：
可以在tail加入新的节点，addNode（x）
可以删除头节点，removeHead()，并返回头结点head，
这样子的话，我们删除头的时候（也就是最久不用least required unused 节点）（LRU），我们要同步把map里面的head节点也干掉，删除。
可以将某一个节点挪到tail去（这些都是LRU中涉及的操作）moveNodeToTail（x）

这样的话，
我们看样例也就知道：
LRUCache内部必须要有双向链表，还有哈希表对应x-value
当put(x,value)时：
（1）可能双向链表中压根没有任何节点，则head=tail都指向x
（2）可能有一个NDLL，但是没有x存在，那需要新加x
（3）可能x已经存在了，只需要更新x的value即可

（4）还有可能NDLL已经满了capacity，需要直接把头那个节点废了（那用removeMostUnusedCache）
注意和这个removeMostUnusedCache函数，它需要返回你删除的head节点
这样我们方便去map表中把这个head废了，这样就代表不再LRUCache中了

（5）当你get一个x时，或者put一个x但是是更新x，都会让这个x跑到tail去
——如果x是head的话，那直接把head分离，放入tail

——如果是tail，那就不动了
——如果是中间x，那就需要分离x，让x前后跳链断开x，把x挪到tail

这些都是链表的最基本操作，非常简单的，在NDLL内部调用就行

好，来把NDLL建出来，方便LRUCache用：

//双向链表，有很多操作
    public static class NDLL<K, V>{
        //参数类型KV泛型
        //俩成员变量
        private Node<K, V> head;
        private Node<K, V> tail;//一头一尾

        public NDLL(){//初始化啥也没有
            head = null;
            tail = null;
        }

        //添加节点---链表自带的操作函数1
        public void addNode(Node<K, V> node){
            //如果链表为空，直接添加，否则就是串接在tail之后
            if (node == null) return;//空节点，不加
            if (head == null){
                head = node;
                tail = node;//头尾都指这一个节点
            }else {
                tail.next = node;
                node.last = tail;
                tail = node;//新的尾
            }
        }

        //有node，将其断掉，移动到尾部，这是很多时候都需要操作的---链表自带的操作函数2
        public void moveNodeToTail(Node<K, V> node){
            //如果是尾部，不挪
            if (node == tail) return;
            //要是头部，挪头
            //要是中间节点，挪中间节点，最后都有一个挂接尾部的
            //首先断开前面
            if (node == head){
                head = head.next;
                head.last = null;//断开
            }else {
                //中间点
                node.last.next = node.next;
                node.next.last = node.last;//跳开互相指
            }

            //然后将node挂到尾部
            node.next = null;
            node.last = tail;
            tail.next = node;
            tail = node;//尾部更新即可
        }

        //如果链表满了，需要删除链表头，和哈希表，因为头最老了---链表自带的操作函数3
        public Node<K, V> removeHead(){
            if (head == null) return null;

            Node<K, V> ans = head;
            if (head == tail){
                //如果就一个节点，全删除
                head = null;
                tail = null;
            }else {
                //还有更多节点
                head = head.next;
                head.last = null;
                ans.next = null;//断开
            }
            return ans;//返回ans好删除哈希表
        }
    }

仔细研读里面的代码，内部的函数就是操作双向链表的
数据类型的话，我们用泛型K,V来定义的，这样调用时放入类型就行，String，Integer，等等都行
其中：removeHead是需要返回节点的，这样我们好废掉LRU中map的x点

有了NDLL，就可以让LRU来实现自己的数据结构了，这也就是本题的最终代码

LRU数据结构，用NDLL作为基本的元素

内部维持2个数据结构：
（1）哈希表map：key是我们的元素x，value就是包装好的节点，这个节点是通过指针串成一个双向链表的NDLL
（2）双向链表NDLL，有一个head指针，一个tail指针，维持容量长度为capacity的双向链表，这就是我们要的LRU主体结构

总体来说，这个NDLL的成员函数，就是我们说的题目要求的那些操作
一个就是加入节点，由于LRU有内存限制，容量超过capacity，那就要删掉最久不用那个头结点，然后重新挂接到NDLL尾部
另一个，就是get函数，每次操作一个节点node，那么需要根据node的不同，把node调整到最新的尾部，它代表最新操作过的东西
node如果在中间，要切断，放尾部，如果node在头，直接断开，放尾部

//LRU内存替换算法
    public static class LRUCache<K, V>{
        //成员变量，我缓存的容量,哈希表，存Node，双向量表，规定时间，同步操作的
        private final int capacity;
        private HashMap<K, Node<K, V>> keyMap;//哈希表
        private NDLL<K, V> nodeList;//链表

        public LRUCache(int c){
            //初始化告诉我缓存的上限，不动
            capacity = c;
            keyMap = new HashMap<>();
            nodeList = new NDLL<>();//最开始哈也没有
        }

        //添加信息---这是LRU的独特函数2
        public void put(K key, V value){
            //两种情况，要么是更新，要么是添加
            if (keyMap.containsKey(key)){
                Node<K, V> node = keyMap.get(key);//更改信息
                node.value = value;//更新
                nodeList.moveNodeToTail(node);//操作过那就得更新时间
            }else {
                //没进来过
                //但此时空间已经满了
                if (capacity == keyMap.size()) removeMostUnusedCache();//先将老东西删除--再添加新生节点
                Node<K, V> newNode = new Node<K, V>(key, value);
                keyMap.put(key, newNode);//新加
                nodeList.addNode(newNode);//链表新加--新加的自然是在结尾，就是最新的
            }
        }

        //缓存满了，删除链表和哈希表的古老信息
        public void removeMostUnusedCache(){
            Node<K, V> head = nodeList.removeHead();//删除链表的头
            keyMap.remove(head.key);//根据这个点的key，删除keyMap
        }

        //get信息---这是LRU的独特函数1
        public V get(K key){
            if (!keyMap.containsKey(key)) return null;//如果没有的话
            Node<K, V> node = keyMap.get(key);
            nodeList.moveNodeToTail(node);//既然我访问了你，除了返回结果之外，我还得记录时间是最新的
            return node.value;
        }
    }

这里要注意的就是这个代码：
为了检查LRU是不是已经满了，满了就废掉最近微操作那个节点

if (capacity == keyMap.size()) removeMostUnusedCache();//先将老东西删除--再添加新生节点

测试代码：

public static void test(){
        LRUCache<String, Integer> lruCache = new LRUCache<>(3);//容量为3的缓存
        lruCache.put("abc", 1);
        lruCache.put("123", 2);
        System.out.println(lruCache.get("abc"));
        lruCache.put("bbb", 2);
        lruCache.put("ccc", 2);

        System.out.println();
    }

    public static void main(String[] args) {
        test();
    }

---

总结

提示：重要经验：

1）LUR内部实际上就是一个1维的双向链表，每次操作都要把涉及到的x放到最后去
2）一旦LRU容量满了，加入不是更新x就要废掉head节点，然后新加入
3）NDLL双向链表有很多自己的内部操作，加入，删除，移动等等，反正基本骚操作，都要学会
4）理解了LRU就能理解下一篇文章的2维双向链表了，它是现在更复杂但是更有意义的缓存替换算法：叫LFU，least Frequency Unused 缓存替换算法