146. LRU Cache

1、题目描述

设计一个LRU的缓存机制。实现get和put函数。

2、思路

用map m记录cache中每个键值对。

用map rec记录每个键被访问的时间戳。

get函数：如果在m中能找到key，则返回，且更新时间戳；若找不到，则返回-1.

普通函数：如果m中能找到key，则更新key对应值，以及时间戳；

如果找不到，若cache没满，则直接插入键值对，和对应的时间戳对。

如果cache满了，则找到时间戳最小的那个key，把它在m和rec中的记录删除，

再插入新的键值对，时间戳对。

3、代码

class LRUCache {
public:
    map<int,int>m;
    map<int,int>rec;
    int t;
    int n;
    int c;
    LRUCache(int capacity) {
        t=0;
        n=0;
        c=capacity;
    }
    
    int get(int key) {
        t++;
        if(c==0) return -1;
        if(m.find(key)==m.end())
            return -1;
        else{
            rec[key]=t;
            return m[key];    
        }
    }
    
    void put(int key, int value) {
        t++;
        if(n>0&&m.find(key)!=m.end()){
            m[key]=value;
            rec[key]=t;
        }
        else{
            if(n<c){
                n++;
                m[key]=value;
                rec[key]=t;
            }
            else{
                map<int,int>::iterator it = rec.begin();
                int k = -1,recmin = INT_MAX;
                for(;it!=rec.end();it++){
                    if(it->second<recmin){
                        k = it->first;
                        recmin = it->second;
                    }
                }
                it = m.find(k);
                m.erase(it);
                it = rec.find(k);
                rec.erase(it);

                m[key]=value;
                rec[key]=t;
            }
        }
        
        
    }
};

法2：

class LRUCache {
    map<int,int> keysAges; //(time,key)
    map<int,pair<int,int>> LRU_CACHE; //(key,(value,time))
    int timer;
    int capacity;
public:
    LRUCache(int capacity) {
        this->capacity = capacity;
        this->timer = 0;
    }
    
    int get(int key) {
        auto&& iter = LRU_CACHE.find(key);
        if(iter == LRU_CACHE.end()) return -1;
        else {
            auto&& elem_time = iter->second.second;
            keysAges.erase(elem_time);
            iter->second.second = timer;
            keysAges[timer++] = key;
            return iter->second.first;
        }    
    }
    
    void put(int key, int value) {
        auto&& iter = LRU_CACHE.find(key);
        if(iter == LRU_CACHE.end()){
            if((LRU_CACHE.size() + 1 > capacity)){
                assert(keysAges.size() >= 1);
                auto&& begin = keysAges.begin();
                LRU_CACHE.erase(begin->second);
                keysAges.erase(begin->first);
            }
        } else {
            auto&& elem_time = iter->second.second;
            keysAges.erase(elem_time);
        }
        LRU_CACHE[key] = pair<int,int>(value,timer);
        keysAges[timer++] = key;
    }
};