About LFU cache and LRU cache

LRU Cache

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.

To achieve the functions mentioned in LRU description, we would use a list to store pair(key, value), because we want these pairs arranged by time; using list enable us to alter the order of pairs in constant time.

class LRUCache{public:    LRUCache(int capacity) {        this->capacity = capacity;    }    int get(int key) {        if(table.find(key) == table.end())            return -1;        else{            timeList.splice(timeList.begin(), timeList, table.find(key)->second);            return table.find(key)->second->second;        }    }    void set(int key, int value) {        if(table.find(key) != table.end()){            timeList.splice(timeList.begin(), timeList, table.find(key)->second);            table.find(key)->second->second = value;            return;        }        if(table.size() == capacity){            table.erase(timeList.back().first);            timeList.pop_back();        }        timeList.emplace_front(key, value);        table[key] = timeList.begin();    }private:    unordered_map<int, list<pair<int,int>>::iterator> table;    size_t capacity;    list<pair<int,int>> timeList;};

LFU Cache

Consider this:

pairIdx:(key,<value,frequency>)

freqIdx:(freq,list<key>)

listIdx:(key,address(key))

At the beginning, I thought pairIdx(⋅) and freqIdx(⋅) is enough, but then I discover that the erase(⋅) operation in list only takes a pointer as argument. Thus, a new map called listIdx is added, which is to store the address of each key in the list.

class LFUCache {public:    LFUCache(int capacity) {        this->capacity = capacity;        size = 0;    }    int get(int key) {        if(pairIdx.find(key) == pairIdx.end())            return -1;        else{            freqIdx[pairIdx[key].second].erase(listIdx[key]);            pairIdx[key].second++;            freqIdx[pairIdx[key].second].push_back(key);            listIdx[key] = --freqIdx[pairIdx[key].second].end();            if(freqIdx[minFreq].size() == 0)                minFreq = pairIdx[key].second;            return pairIdx[key].first;        }    }    void set(int key, int value) {        //  Set        if(capacity <= 0)   return;        if(pairIdx.find(key) != pairIdx.end()){            pairIdx[key].first = value; //  Change value            //  Change freq            freqIdx[pairIdx[key].second].erase(listIdx[key]);            pairIdx[key].second++;            freqIdx[pairIdx[key].second].push_back(key);            if(freqIdx[minFreq].size() == 0)                minFreq = pairIdx[key].second;            //  Change pointer to key in list            listIdx[key] = --freqIdx[pairIdx[key].second].end();            return;        }        //  Delete        if(size >= capacity){            pairIdx.erase(freqIdx[minFreq].front());            listIdx.erase(freqIdx[minFreq].front());            freqIdx[minFreq].pop_front();            size--;        }        //  Insert        minFreq = 1;        pairIdx[key] = {value, 1};        freqIdx[1].push_back(key);        listIdx[key] = --freqIdx[1].end();        size++;    }private:    unordered_map<int, pair<int, int>> pairIdx;    unordered_map<int, list<int>::iterator> listIdx;    unordered_map<int, list<int>> freqIdx;    int capacity, minFreq, size;};