LRU缓存及其代码实现

一、什么是LRU缓存算法

LRU，Least Recently Used算法，即一种缓存淘汰策略。

计算机的缓存容量有限，若缓存满了则需要删除一些内容，给新的缓存腾出空间，但问题是要删除哪些内容呢？当然是把用的少的缓存删掉，把最有用的数据继续保留以便于继续使用。那么如何判定哪些数据是有用的呢？

缓存淘汰的策略有很多，而LRU则是一种较为简单常用的算法，LRU判定最近使用过的数据为有用的，很久都没用过的数据是无用的，在内存满了就优先删除很久未使用，也就是无用的数据。

二、如何实现LRU缓存算法

LRU 缓存机制可以通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。

双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。

这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)O(1) 的时间内完成 get 或者 put 操作。具体的方法如下：

对于 get 操作，首先判断 key 是否存在：

如果 key 不存在，则返回 -1−1；

如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。

对于 put 操作，首先判断 key 是否存在：

如果 key 不存在，使用 key 和 value 创建一个新的节点，在双向链表的头部添加该节点，并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；

如果 key 存在，则与 get 操作类似，先通过哈希表定位，再将对应的节点的值更新为 value，并将该节点移到双向链表的头部。

上述各项操作中，访问哈希表的时间复杂度为 O(1)O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)O(1)。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O(1)O(1) 时间内完成。

实现 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) 的平均时间复杂度运行。

//创建一个结点类，用于实现双向链表
class Node {
public:
    int key;
    int val;
    Node* prev, *next;
    Node(): key(0), val(0), prev(nullptr), next(nullptr) {}
    Node(int _key, int _value): key(_key), val(_value), prev(nullptr), next(nullptr) {}
};
class LRUCache {
public:
    //通过哈希表进行访问查找
    unordered_map<int, Node*> hash;
    Node *head;
    Node *tail;
    int size;
    int capacity;
    //初始化
    LRUCache(int capacity) {
        head = new Node();
        tail = new Node();
        head -> next = tail;
        tail -> prev = head;
        this -> capacity = capacity;
        this -> size = 0;
    }
    
    int get(int key) {
        //如果关键字key存在于缓存中，返回关键字的值
        //并且将访问的结点移到开头
        if(hash.count(key)) {
            Node *temp = hash[key];
            movetoHead(temp);
            return temp -> val;
        }
        //否则返回-1
        return -1;
    }
    
    void put(int key, int value) {
        //如果关键字key存在于缓存中，更新关键字的值，并移动到开头
        if(hash.count(key)) {
            Node *temp = hash[key];
            temp -> val = value;
            movetoHead(temp);
        }
        //如果不存在，则新建结点插入到开头
        //如果关键字数量大于规定的capacity，则逐出末尾的节点
        else {
            ++size;
            Node *temp = new Node(key, value);
            addtoHead(temp);
            hash[key] = temp;
            if(size > capacity) {
                Node *del = removetail();
                hash.erase(del -> key);
                delete del;
                --size;
            }
        }
    }
    //删除结点
    void removeNode(Node *node) {
        node -> prev -> next = node -> next;
        node -> next -> prev = node -> prev;
    }
    //添加结点到链表头
    void addtoHead(Node *node) {
        node -> prev = head;
        node -> next = head -> next;
        head -> next -> prev = node;
        head -> next = node;
    }
    //移除结点并将该结点移动到表头
    void movetoHead(Node *node) {
        removeNode(node);
        addtoHead(node);
    }
    //删除末尾最久未使用的关键字
    Node *removetail() {
        Node *temp = tail -> prev;
        removeNode(temp);
        return temp;
    }
};