146. LRU缓存机制

一、什么是 LRU 算法

就是一种缓存淘汰策略。

计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。但问题是，删除哪些内容呢？我们肯定希望删掉哪些没什么用的缓存，而把有用的数据继续留在缓存里，方便之后继续使用。那么，什么样的数据，我们判定为「有用的」的数据呢？

LRU 缓存淘汰算法就是一种常用策略。LRU 的全称是 Least Recently Used，也就是说我们认为最近使用过的数据应该是是「有用的」，很久都没用过的数据应该是无用的，内存满了就优先删那些很久没用过的数据。

举个简单的例子，安卓手机都可以把软件放到后台运行，比如我先后打开了「设置」「手机管家」「日历」，那么现在他们在后台排列的顺序是这样的：

但是这时候如果我访问了一下「设置」界面，那么「设置」就会被提前到第一个，变成这样：

假设我的手机只允许我同时开 3 个应用程序，现在已经满了。那么如果我新开了一个应用「时钟」，就必须关闭一个应用为「时钟」腾出一个位置，关那个呢？

按照 LRU 的策略，就关最底下的「手机管家」，因为那是最久未使用的，然后把新开的应用放到最上面：

现在你应该理解 LRU（Least Recently Used）策略了。当然还有其他缓存淘汰策略，比如不要按访问的时序来淘汰，而是按访问频率（LFU 策略）来淘汰等等，各有应用场景。本文讲解 LRU 算法策略。

二、LRU 算法描述

LRU 算法实际上是让你设计数据结构：首先要接收一个 capacity 参数作为缓存的最大容量，然后实现两个 API，一个是 put(key, val) 方法存入键值对，另一个是 get(key) 方法获取 key 对应的 val，如果 key 不存在则返回 -1。

注意哦，get 和 put 方法必须都是 O(1)O(1) 的时间复杂度，我们举个具体例子来看看 LRU 算法怎么工作。

C++
/* 缓存容量为 2 */
LRUCache cache = new LRUCache(2);
// 你可以把 cache 理解成一个队列
// 假设左边是队头，右边是队尾
// 最近使用的排在队头，久未使用的排在队尾
// 圆括号表示键值对 (key, val)

cache.put(1, 1);
// cache = [(1, 1)]
cache.put(2, 2);
// cache = [(2, 2), (1, 1)]
cache.get(1);       // 返回 1
// cache = [(1, 1), (2, 2)]
// 解释：因为最近访问了键 1，所以提前至队头
// 返回键 1 对应的值 1
cache.put(3, 3);
// cache = [(3, 3), (1, 1)]
// 解释：缓存容量已满，需要删除内容空出位置
// 优先删除久未使用的数据，也就是队尾的数据
// 然后把新的数据插入队头
cache.get(2);       // 返回 -1 (未找到)
// cache = [(3, 3), (1, 1)]
// 解释：cache 中不存在键为 2 的数据
cache.put(1, 4);    
// cache = [(1, 4), (3, 3)]
// 解释：键 1 已存在，把原始值 1 覆盖为 4
// 不要忘了也要将键值对提前到队头

三、LRU 算法设计

分析上面的操作过程，要让 put 和 get 方法的时间复杂度为 O(1)O(1)，我们可以总结出 cache 这个数据结构必要的条件：查找快，插入快，删除快，有顺序之分。

因为显然 cache 必须有顺序之分，以区分最近使用的和久未使用的数据；而且我们要在 cache 中查找键是否已存在；如果容量满了要删除最后一个数据；每次访问还要把数据插入到队头。

那么，什么数据结构同时符合上述条件呢？哈希表查找快，但是数据无固定顺序；链表有顺序之分，插入删除快，但是查找慢。所以结合一下，形成一种新的数据结构：哈希链表。

LRU 缓存算法的核心数据结构就是哈希链表，双向链表和哈希表的结合体。这个数据结构长这样：

思想很简单，就是借助哈希表赋予了链表快速查找的特性嘛：可以快速查找某个 key 是否存在缓存（链表）中，同时可以快速删除、添加节点。回想刚才的例子，这种数据结构是不是完美解决了 LRU 缓存的需求？

也许读者会问，为什么要是双向链表，单链表行不行？另外，既然哈希表中已经存了 key，为什么链表中还要存键值对呢，只存值不就行了？

想的时候都是问题，只有做的时候才有答案。这样设计的原因，必须等我们亲自实现 LRU 算法之后才能理解，所以我们开始看代码吧～

class LRUCache {
    public:
        LRUCache(int capacity):_capacity(capacity) {
        }

        int get(int key) {
            auto ite = list_iterator_map.find(key);
            // 这个key存在
            if (ite != list_iterator_map.end()) {
                // 保存一下这个节点pair
                std::pair<int, int> ite_bak = *(ite->second);
                // 在链表中删除这个节点
                lru_list.erase(ite->second);
                // 重新将这个pair设置到链表中
                lru_list.push_front(ite_bak);
                // 更新hash表中的迭代器
                list_iterator_map[key] = lru_list.begin(); 
                return ite_bak.second; 
            }
            return -1;
        }

        void put(int key, int value) {
            auto ite = list_iterator_map.find(key);
            // map中存在这个节点
            if (ite != list_iterator_map.end()) {
                // list中删除这个节点
                lru_list.erase(ite->second);
                // 将这个节点更新到list的头部
                lru_list.push_front(std::pair<int, int>(key, value));
                // 更新hash表中这个节点迭代器值
                ite->second = lru_list.begin(); 
            } else {
                // 超过容量
                if (lru_list.size() == _capacity) {
                    // 删除hash表中的值
                    list_iterator_map.erase(lru_list.back().first);
                    // 删除链表的尾部,尾部是最近没有访问的
                    lru_list.pop_back();
                }
                // 在链表的头部插入节点
                lru_list.push_front(std::pair<int, int>(key, value));
                // 将该节点放入hash表中
                list_iterator_map[key] = lru_list.begin();
            }
        }
    private:
        std::unordered_map<int, std::list<std::pair<int, int>>::iterator> list_iterator_map; 
        std::list<std::pair<int, int>> lru_list;
        int _capacity;
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

class LRUCache {
    public:
    LRUCache(int capacity) {
        _capacity = capacity;
        _table.clear();
        _que.clear();
    }

    int get(int key) {
        if(_table.find(key) == _table.end()) {
            return -1;
        }
        auto ite = _table.find(key);
        _que.push_back(make_pair(key, ite->second->second));
        _que.erase(ite->second);
        _table[key] = std::prev(_que.end());
        return _table[key]->second;
    }

    void put(int key, int value) {
        // 这个地方必要先判断，这个key之前是否存在过
        if(_table.find(key) != _table.end()) {
            auto ite = _table[key];
            _que.erase(ite);
            _que.push_back(make_pair(key,value));
            _table[key] = std::prev(_que.end());
            return;
        }
        if(_capacity <= _que.size()) {
            auto front = _que.front();
            _table.erase(front.first);
            _que.pop_front();
        }
        _que.push_back(make_pair(key, value));
        _table[key] = std::prev(_que.end());
    }
private:
    std::unordered_map<int, std::list<std::pair<int, int>>::iterator> _table;
    std::list<std::pair<int, int>> _que;
    int _capacity;
};

/**
 *  * Your LRUCache object will be instantiated and called as such:
 *   * LRUCache* obj = new LRUCache(capacity);
 *    * int param_1 = obj->get(key);
 *     * obj->put(key,value);
 *      */