【数据结构】LRU cache

一、什么是LRU cache

一种缓存淘汰机制

什么是cache？通常指得速度相差较大的俩个硬件之间，用于协调二者数据传输的速度的一种结构。类如在CPU和内存、内存和硬盘。cache的容量是有限的，必然存在淘汰！

LRU是最近很少使用。我们通常认为最近使用的数据是有用的，很少使用是无用的，应该被优先淘汰掉。

例如在手机后台中，当运行的软件超过一定的内存时，最先淘汰掉的是很少使用的软件。

二、LRU cache的设计

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

这种淘汰机制要实现所有的操作都是常数次的时间复杂度，实现增删查改0(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

查找到数据O(1)的时间复杂度需要借助哈希表

添加一个数据到哈希表中的时间复杂度也是O(1)。

但是让这个元素更新到最前，哈希表不能做到，就要借助链表。队列中，我们不知道元素在哪里，遍历是O(N)的时间。

为了解决寻找，就要把key和链表的迭代器（这里是每一个结点的指针）绑定在一起，通过查找哈希表，就能知道在队列中的位置。

如果要更新元素到最前，要同时修改哈希表的映射和在队列中的位置。

三、结构实现

框架

哈希表的K放key ,V放链表迭代器

同时包含capacity，用于push的淘汰

    size_t _capacity;
    unordered_map<int ,list<pair<int,int>>::iterator> _HashMap;
    list<pair<int ,int>> _list;

get() 获取和更新

先通过哈希表找key，second就是迭代器，返回迭代器的second,并将该结点转移到链表的首位

    int get(int key) {
        auto hashit=_HashMap.find(key);
        //找到
        if(hashit!=_HashMap.end())
        {
            auto it=hashit->second;
           _list.splice(_list.begin(),_list ,it);

           return it->second; 
        }
        else
        {
            return -1;
        }
    }

splice函数的用法
void splice (iterator position, list& x, iterator i)
将目标迭代器转移到一个链表的位置

put 插入和更新

先在哈希表中查找映射 关系：

如果不存在就将再检查是否满了。如果满了，就要尾删，因为list是双向链表，尾删的代价是0(1) 。插入时，是头插，并且用迭代器更新哈希表。

如果存在，就更新value并且将结点移到最前面（逻辑同get）

这里的淘汰机制就是删除链表的最后一个位置，并且删除哈希表中的映射关系。

    void put(int key, int value) 
    {
        auto hashit=_HashMap.find(key);
        if(hashit==_HashMap.end())
        {
            //检查扩容
            if(_capacity==_HashMap.size())
            {
                //尾删
                auto back=_list.back();
                _HashMap.erase(back.first);
                _list.pop_back();
            }

            //新增
            _list.push_front(make_pair(key,value));
            _HashMap[key]=_list.begin();
        }
        else{
            auto it=hashit->second;
            it->second=value;
           _list.splice(_list.begin(),_list ,it); 
        }
    }

Gitee：代码

关键点是删除

转移

掌握了这俩个关键点，这道题就能顺利解决。

本题很考验基础功底，是一道不错的面试题。