[Leetcode Solution] LRU Cache

LRU, also known as "Least Recently Used", is a cache algorithm which discards the the least recently used entry when we push a new entry to the cache.

This problem wants us to implement two function "int get(int key)" and "void set(int key, int value)" which means to get a record and add a new record in the cache(if the cache is full, remove the least recently used one). The hardest part is how to track which record is used and when.

I have implemented two version of solutions which both can get an "Accepted". 

The first one uses std::map and std::list to track the records. The std::map contains the pair of <key, pointer_to_value>, at the same time, the std::list stores the values and the list is ordered by the recent used time.

class LRUCache{
public:
    struct Entry {
        int key, value;
        Entry(){}
        Entry(int ikey, int ivalue): key(ikey), value(ivalue) {}
    };

    LRUCache(int icap): capacity(icap) {}
    
    int get(int key) {
        if (mp.find(key) == mp.end()) {
            return -1;
        }
        int res = mp[key] -> value;
        move_front(key);
        return res;
    }

    void set(int key, int value) {
        if (mp.find(key) != mp.end()) {
            mp[key] -> value = value;
            move_front(key);
        } else {
            Entry res(key, value);
            if (lst.size() >= capacity) {
                pop_back();
            }
            lst.push_front(res);
            mp[key] = lst.begin();
        }
    }
    
private:
    map<int, list<Entry>::iterator> mp;
    list<Entry> lst;
    int capacity;
    
    void move_front(int key) {
        //ASSERT_NE(mp.find(key), mp.end())
        Entry e = *mp[key];
        auto iter = mp[key];
        lst.erase(iter);
        lst.push_front(e);
        mp[key] = lst.begin();
    }
    
    void pop_back() {
        Entry e = *(--lst.end());
        mp.erase(e.key);
        lst.pop_back();
    }
};

The second version only use one std::map the maintain all these record by implementing a double-linked list of the nodes of std::map, of course the list is sorted by the recent used time. Each node in the std::map contains a "previous" and a "next" record to indicate the key of the adjacent node in the list. And we also need a top/bottom pointer to indicate the first and last node of the list.

However, the second version is more complicated that I won't use that code in the interview.

class LRUCache {
public:
    LRUCache(int icap);
    int get(int key);
    void set(int key, int value);
    void show();
private:
    struct entry {
        int value, pre, next;
        entry(){}
        entry(int ivalue, int ipre, int inext): \
                value(ivalue), pre(ipre), next(inext){}
    };

    void cache_remove(int key);
    void cache_add(int key, int value);
    
    size_t cap;
    map<int, entry> mp;
    int top, buttom;

    static const int INVALID = -1;
};

LRUCache::LRUCache(int icap): cap(icap)
{
    top = buttom = INVALID;
    mp.clear();
}

void LRUCache::show()
{
    int now = top;
    while (now != INVALID) {
        auto iter = mp.find(now);
        printf("<%d, %d>", now, (iter -> second).value);
        now = (iter -> second).next;
    }
    puts("");
}

void LRUCache::cache_remove(int key)
{
    if (key == INVALID) {
        return;
    }
    
    auto iter = mp.find(key);
    int pre = (iter -> second).pre;
    int next = (iter -> second).next;

    if (pre != INVALID) {
        (mp.find(pre) -> second).next = next;
    }
    if (next != INVALID) {
        (mp.find(next) -> second).pre = pre;
    }

    if (key == buttom) {
        buttom = pre;
    }
    if (key == top) {
        top = next;
    }
    
    mp.erase(iter);
}

void LRUCache::cache_add(int key, int value)
{
    entry e(value, INVALID, top);
    (mp.find(top) -> second).pre = key;
    mp.insert(make_pair<int, entry>(int(key), entry(e)));
    if (mp.size() > this -> cap) {
        cache_remove(buttom);
    }
    top = key;
    if (mp.size() == 1) {
        this -> buttom = key;
    }
}

int LRUCache::get(int key)
{
    if (mp.find(key) == mp.end()) {
        return -1;
    }

    int value = (mp.find(key) -> second).value;
    cache_remove(key);
    cache_add(key, value);
    return value;  
}

void LRUCache::set(int key, int value)
{
    if (mp.find(key) != mp.end()) {
        cache_remove(key);
    }
    cache_add(key, value);
}

The time complexity of the algorithm is as same as the get/set function of the std::map.