每日一练之设计 LRU 缓存结构

设计 LRU 缓存结构

OJ 地址：设计 LRU 缓存结构

#include <unordered_map>
class Solution {
private:
    // 维护一个有序单向链表，当有一个新的数据被访问时，从链表头部开始遍历链表：
    // 1 如果此数据之前已经在缓存中了，那么将其从原来的位置删除，并将其插入到头节点
    // 2 如果此数据之前不在缓存中：
    //   2.1 如果缓存未满，则直接将此节点插入到头节点
    //   2.2 如果缓存已满，则删除链表尾节点，将新的数据插入到头节点
    // 复杂度为O(n)
     
     
    // 使用散列表hashtable与双向链表的组合
    // 当要缓存某个数据的时候，先在链表中查找这个数据。如果没有找到，则直接将数据放到链表的尾部；如果找到了，我们就把它移动到链表的尾部
    // 当缓存空间不够，需要淘汰一个数据的时候，我们就直接将链表头部的结点删除
    // 复杂度为O(1)
    vector<int> cache; // 缓存：cache 首元素存放最不常用的 key，最后一个元素存放活跃的 key
    unordered_map<int, int> map;
public:
    /**
     * lru design
     * @param operators int整型vector<vector<>> the ops
     * @param k int整型 the k
     * @return int整型vector
     */
    void set(int key, int val, int k)
    {
        if(cache.size() == k)
        {
            map.erase(cache[0]);  // 删除最不活跃元素
            cache.erase(cache.begin());    // 删除缓存首元素，也是不活跃元素
        }
        map[key] = val;
        // 在 cache 中查找是否有 key，有的话，就将 key 放到 cache 末尾，成为活跃 key
        for(int i = 0; i < cache.size(); i++)
        {
            if(cache[i] == key)
            {
                cache.erase(cache.begin() + i);
                break;
            }
        }
        cache.push_back(key); // 放到末尾
    }
    int get(int key)
    {
        if(map.find(key) == map.end())
            return -1;
        // 在 cache 中查找，如果有，则放到末尾成为活跃 key
        for(int i = 0; i < cache.size(); i++)
        {
            if(cache[i] == key)
            {
                cache.erase(cache.begin() + i);
                cache.push_back(key);
                break;
            }
        }
        return map[key];
    }
    vector<int> LRU(vector<vector<int> >& operators, int k) {
        // write code here
        vector<int> res;
        for(int i = 0; i < operators.size(); i++)
        {
            if(operators[i][0] == 1)
                set(operators[i][1], operators[i][2], k);
            else
                res.push_back(get(operators[i][1]));
        }
        return res;
    }
};