【leetcode】LRU Cache(hard)★

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

 

思路：

这题吧，思路挺清楚的，就是每次get, set时都把对应的数据设为时间最近的数据，如果满了，就在set时把最老的数据扔掉，把新的插入到最近的位置。

关键是，如何在O(1)的时间内get到所需的数据，如何在O(1)的时间内，找到最老的数据。

第一个问题可以用unordered_map轻松解决，但是，第二个问题我就不会了。我很low的用了遍历，果断超时了。看答案后发现，要用list的splice函数解决。

把所有的数据按照访问时间由近到远存放在一个list中，当再次访问里面的数据时，就把该数据移动到list的开始位置，满了后就移除list的最后一个元素。

上大神的答案：

class LRUCache {
private:
    // A list of (key, value) pairs
    list<pair<int, int>> items;
    // Map items to iterators (pointers) to list nodes
    unordered_map<int, list<pair<int, int>>::iterator> cache;
    // The capacity of the list
    int capacity;

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        // If key is not found in hash map, return -1
        if (cache.find(key) == cache.end())
            return -1;
        // Move the (key, value) pair to the beginning of the list
        items.splice(items.begin(), items, cache[key]);
        return cache[key]->second;
    }

    void set(int key, int value) {
        // The key is not in the hash table
        if (cache.find(key) == cache.end()) {
            // If the cache is full then delete the least recently
            // used item, which is at the end of the list
            if (items.size() == capacity) {
                cache.erase(items.back().first);
                items.pop_back();
            }
            items.push_front(make_pair(key, value));
            cache[key] = items.begin();
        } else {
            // Update the value associated with the key
            cache[key]->second = value;
            // Move the (key, value) pair to the beginning of the list
            items.splice(items.begin(), items, cache[key]);
        }
    }
}

 

 

我的代码，时间是用自己设的time来记录的，超时了。

typedef struct Data
{
    int value;
    int time;
    Data(){}
    Data(int v, int t) : value(v), time(t){}
}Data;

class LRUCache{
public:
    LRUCache(int capacity) {
        t = 0;                //初始化时间
        c = capacity;         //初始化容量
    }
    
    int get(int key) {
        unordered_map<int, Data>::iterator it = record.find(key);
        if(it == record.end())
        {
            return -1;
        }
        else
        {
            it->second.time = t++;
            return it->second.value;
        }

    }
    
    void set(int key, int value) {
        if(record.find(key) != record.end())
        {
            record[key].value = value;
            record[key].time = t++;
            return;
        }
        if(record.size() == c)   //容量已经达到
        {
            unordered_map<int, Data>::iterator replace = record.begin();
            for(unordered_map<int, Data>::iterator it = record.begin(); it != record.end(); it++)
            {
                replace = (it->second.time < replace->second.time) ? it : replace;
            }
            record.erase(replace); //删掉时间最早的
        }

        Data newData(value, t);
        record[key] = newData;
        t++;
    }
private:
    unordered_map<int, Data> record;
    int c;
    int t;
};