LRUCache

---

一、什么是LRU Cache

LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或网络内容缓存等。

Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

二、LRU Cache的实现

使用双向链表和哈希表的搭配是最高效和经典的。使用双向链表是因为双向链表可以实现任意位置O(1)的插入和删除，使用哈希表是因为哈希表的增删查改也是O(1)。

三、用OJ题来演示一下

leetcode跳转链接

1、题目描述

2、题目思路

我们先创建两个数据结构，根据上面的LRU Cache实现我们创建一个unordered_map的hash表，再创建一个LRUList的双向链表，我们本次实现的是将长时间未用的数据放到链表尾部，容量满了就删除尾部结点即可，如果中间遇到更新的结点的时候在链表中部，取出链表中部后将其头插到链表头部即可。

但我们写代码的时候绝对遇到一个问题，就是这个hash表应该怎么定义？我们定义成unordered_map<int, int>?分析一下，假如说是要找中间结点的话，其hash的second对应的是不是需要去遍历这个链表去找？那么时间复杂度就是O（N）了，所以我们转换思路，hash的second是个迭代器，指向链表相对应的位置，这不是直接就能找到对应的位置了吗！

我们绝对会遇到的问题就是迭代器失效的问题，我们第一种方法可以用到erase_push_front两个函数接口，解决迭代器失效的问题，也可以用一个很冷门的接口splice，我们用文档一看：
我们下面实现的是erase+push_front的接口，其实很简单，取出迭代器，删除当前迭代器位置，将取出来的迭代器头插，再映射hashmap的对应关系即可。

get接口其实就是取到缓冲区对应关键字的值即可，我们只需要用迭代器去寻找然后return即可。
put接口其实就是放入即可，容量不够的话我们就删除链表尾部结点然后再头插新的结点；容量够的话直接头插即可。

3、代码

class LRUCache 
{
public:
    LRUCache(int capacity)
        : _capacity(capacity)
    {}
    
    int get(int key)
    {
        auto it = _hashmap.find(key); // 找的是对应key-value的后面的迭代器
        if (it != _hashmap.end())
        {
            // 使用erase+push_front应对迭代器失效的问题
            auto ret = it->second; // 先拿出迭代器
            pair<int, int> kv = *ret; // 先将这个迭代器的值拿出来
            _LRHList.erase(ret); // 删除这个list结点
            _LRHList.push_front(kv); // 头插
            _hashmap[key] = _LRHList.begin(); // kv对应关系在hash表中映射
            return kv.second;
        }
        else
        {
            return -1; // 没找到
        }
    }
    
    void put(int key, int value) 
    {
        // 更新+新增
        auto it = _hashmap.find(key);
        if (it == _hashmap.end())
        {
            // 新增，满了就删除尾部数据
            if (_hashmap.size() >= _capacity)
            {
                pair<int, int> back = _LRHList.back(); // 先拿出尾部数据
                _hashmap.erase(back.first); // 删除hash对应的key
                _LRHList.pop_back(); // 弹出list尾部数据
            }
            // 插入
            _LRHList.push_front(make_pair(key, value));
            _hashmap[key] = _LRHList.begin();
        }
        else
        {
            // 更新key所对应的位置
            auto ret = it->second;
            ret->second = value;

            // 使用erase+push_front应对迭代器失效的问题
            auto r = it->second; // 先拿出迭代器
            pair<int, int> kv = *r; // 先将这个迭代器的值拿出来
            _LRHList.erase(r); // 删除这个list结点
            _LRHList.push_front(kv); // 头插
            _hashmap[key] = _LRHList.begin(); // kv对应关系
        }
    }
private:
    typedef list<pair<int, int>>::iterator ITRator; // list的迭代器
    // unordered_map的hash表要做到查找更新的时间复杂度为O（1）
    // second就是指针指向我们的LRUList的相对应的位置
    // 因为指向相对应的位置就是能直接找到这个位置，不需要遍历
    // 简而言之就是提前指向关系了
    std::unordered_map<int, ITRator> _hashmap;
    // 这个链表存的是key-value对应关系
    std::list<pair<int, int>> _LRHList;
    size_t _capacity;
};