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;
};