LRU缓存机制

 

题目：

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

分析：用双向链表实现缓存中结点(地址+值，即key+value),用unordered_map作辅助查找，效率达到O（1）

class LRUCache {
    
public:
    struct KV
    {
        int _k;//地址
        int _v;//内容
    };
    
    LRUCache(int capacity) {
        //构造函数
        _capacity=capacity;
    }
    
    int get(int key) {
        //获取key对应的value
        //先找看有没有，有的话将其结点保存，并删除在原来的位置，并将其插入在头部；没有的话返回-1
        auto it=map.find(key);
        if(it!=map.end())//找到了
        {
            auto ret=it->second;//找到这个key对应的map结点的迭代器
            KV kv=*ret;//取出该结点
            _list.erase(ret);//删除这个结点再原来的位置
            
            _list.push_front(kv);//头插
            map[key]=_list.begin();//改变key对应的迭代器位置
            
            return kv._v;//返回-v
        }
        else//没找到
        {
            return -1;
        }
    }
    
    void put(int key, int value) {
        //先看有没有，有的话保存该节点，删除原来的位置，并更新该key对应的value,并将其头插；
        //没有的话，先看满不满，不满的话直接头插该节点，满的话将尾删一个，再将该节点头插在链表头部
        auto it=map.find(key);
        if(it==map.end())//没有
        {
            if(_list.size()>=_capacity)//满了
            {
                //需要置换
                KV kv=_list.back();//保存尾节点
                _list.pop_back();//list中删除尾节点
                map.erase(kv._k);//map中也要删除对应节点    
            }
            //满了尾删后，或者没满，则都要将新节点做头插
            _list.push_front({key, value});
            map[key]=_list.begin();
        }
        else//有
        {
            auto ret=it->second;//指向找到节点的迭代器
            KV kv=*ret;//拿到这个结点
            kv._v=value;//更新key对应的value
            
            _list.erase(ret);//删除在原来的位置
            _list.push_front(kv);//再头插
            map[key]=_list.begin();//更新map的对应迭代器
        } 
    }
    
private:
    
    int _capacity;//缓存的容量
    list<KV> _list;//缓存里面的页连起来的链表(页项由地址+内容组成)
    unordered_map<int, list<KV>::iterator> map;//存放地址+链表中结点的迭代器
};