【leetcode】146. LRU缓存机制

题目描述：146

参考

分析：

LRU（Least Recently Used，最近最少使用）淘汰内存策略，最近使用的根据时间局部性永远放在队首、最不常使用放在队尾，当内存满了的时候淘汰掉不常使用的。

本题要求设计：

1 容量capacity；

2  put(key, val) 方法存入键值对； 时间复杂度为 O(1)

3  get(key) 方法获取 key 对应的 val，如果 key 不存在则返回 -1。时间复杂度为 O(1)

看到O(1)必然想起hashmap的查找，为了删除和插入也达到了O(1)，则缓存容器为双链表。

之所以不是单向链表，是因为：删除一个节点不光要得到该节点本身的指针，也需要操作其前驱节点的指针，而双向链表才能支持直接查找前驱，保证操作的时间复杂度 O(1)。

借助哈希表赋予了链表快速查找的特性嘛：可以快速查找某个 key 是否存在缓存（链表）中，同时可以快速删除、添加节点。

时间复杂度分析：

伪代码：

int get(int key) {
    if (key 不存在) {
        return -1;
    } else {        
        将数据 (key, val) 提到开头；
        return val;
    }
}

void put(int key, int val) {
    Node x = new Node(key, val);
    if (key 已存在) {
        把旧的数据删除；
        将新节点 x 插入到开头；
    } else {
        if (cache 已满) {
            删除链表的最后一个数据腾位置；
            删除 map 中映射到该数据的键；
        } 
        将新节点 x 插入到开头；
        map 中新建 key 对新节点 x 的映射；
    }
}

代码实现：

class LRUCache {
public:
    //删除、查找、插入的复杂度都O（1）
    LRUCache(int capacity) {
        cap=capacity;
    } 
    int get(int key) {
        if(m.count(key)==0) return -1;
        else//key存在，更新到表头
        {
            auto iter = m.find(key);//找到对应结点地址
            l.splice(l.begin(),l,iter->second);//移动到链表头
            return l.begin()->second;//返回value
        }
    }
    
    void put(int key, int value) {
        if(m.count(key)==0) {//key不存在，加入进去
            //如果容量到了，删除尾部元素,再加上新结点
            if(l.size()==cap)   {
                m.erase(l.back().first);
                l.pop_back();
            }//直接添加
            l.push_front(make_pair(key,value));
            m[key]=l.begin(); 
        }
        else {//如果key存在，插入相同key的元素，除了要移动，value也需要更新
            auto iter = m[key];//【注意：这里的iter指向链表，即hashmap的第二元素，链表的迭代器】
            iter->second=value;//更新地址value
            l.splice(l.begin(),l,iter);//移动到链表头
            m[key]=l.begin();   //更新hashtable的value
        }
    }
private:
    int cap = 0;
    list<pair<int, int>> l;
    unordered_map<int, list<pair<int, int>>::iterator> m;
};

简化：参考

class LRUCache{
public:
    LRUCache(int capacity) {
        cap = capacity;
    }
    
    int get(int key) {
        auto it = m.find(key);//【注意：这里的it是hashmap的迭代器，it->second是链表的迭代器，it->second->second才是val】
        if (it == m.end()) return -1;
        l.splice(l.begin(), l, it->second);
        return it->second->second;
    }
    
    void put(int key, int value) {
        auto it = m.find(key);
        if (it != m.end()) l.erase(it->second);
        l.push_front(make_pair(key, value));
        m[key] = l.begin();
        if (m.size() > cap) {
            int k = l.rbegin()->first;
            l.pop_back();
            m.erase(k);
        }
    }
    
private:
    int cap;
    list<pair<int, int>> l;
    unordered_map<int, list<pair<int, int>>::iterator> m;
};
或者
class LRUCache {
public:
    LRUCache(int capacity) {
        cap = capacity;
    }
    
    int get(int key) {
        if(!m.count(key)) return -1;
        auto it = m.find(key);
        l.splice(l.begin(), l, it->second);
        return l.begin()->second;
    }
    
    void put(int key, int value) {
        auto it = m.find(key);
        if(it != m.end()) l.erase(it->second);
        l.push_front(make_pair(key, value));
        m[key] = l.begin();
        if(m.size()>cap){
            int k = l.rbegin()->first;//
            l.pop_back();
            m.erase(k);
        }
    }
private:
    int cap = 0;
    list<pair<int, int>> l;
    unordered_map<int, list<pair<int, int>>::iterator> m;
};