手撕LFU缓存和LRU缓存

1、LRU缓存

struct LRUnode {
    LRUnode* next;
    LRUnode* prev;
    int key, value;
    LRUnode():next(nullptr), prev(nullptr), key(0), value(0) {}
    LRUnode(int m_key, int m_value):key(m_key), value(m_value), next(nullptr), prev(nullptr) {}
};

class LRUCache {

private:
    unordered_map<int, LRUnode*> mp;
    int m_capacity;
    LRUnode* head;
    LRUnode* tail;
    int size;
public:
    LRUCache(int capacity):m_capacity(capacity), size(0) {
        head = new LRUnode();
        tail = new LRUnode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if(mp.count(key)) {
            adjustToHead(mp[key]);
            return mp[key]->value;
        }
        return -1;
    }
    
    void put(int key, int value) {
        if(mp.count(key)) {
            mp[key]->value = value;
            adjustToHead(mp[key]);
        }
        else {
            LRUnode* newNode = new LRUnode(key, value);
            addToHead(newNode);
            mp[key] = newNode;
            ++size;
           while(size > m_capacity) {
                LRUnode* cur = removeTail();
                mp.erase(cur->key);
                delete cur;
                --size;
            }
        }
    }

    void addToHead(LRUnode* newNode) {
        newNode->prev = head;
        newNode->next = head->next;
        head->next = newNode;
        newNode->next->prev = newNode;
    }

    void adjustToHead(LRUnode* newNode) {
        remove(newNode);
        addToHead(newNode);


    }

    void remove(LRUnode* newNode) {
        newNode->prev->next = newNode->next;
        newNode->next->prev = newNode->prev;
    }

    LRUnode* removeTail() {
        LRUnode* node = tail->prev;
        remove(node);
        return node;
    }

2、LFU缓存

struct LFUnode {
    int freq, value, key;
    LFUnode():freq(0), value(0), key(0) {}
    LFUnode(int m_freq, int m_value, int m_key):freq(m_freq), value(m_value), key(m_key) {}
};

class LFUCache {
private:
    unordered_map<int, list<LFUnode>::iterator> keyMp;
    unordered_map<int, list<LFUnode>> freqMp;
    int m_capacity, m_size, minfreq;
public:
    LFUCache(int capacity):m_capacity(capacity), m_size(0), minfreq(0) {
        keyMp.clear();
        freqMp.clear();
    }
    
    int get(int key) {
        if(m_capacity == 0) return -1;
        else {
            if(!keyMp.count(key)) return -1;
            else {
                auto it = keyMp[key];
                int value = it->value, freq = it->freq;
                freqMp[freq].erase(it);
                if(freqMp[freq].size() == 0) {
                    freqMp.erase(freq);
                    if(minfreq == freq) minfreq += 1;
                }
                freqMp[freq + 1].push_front(LFUnode(freq + 1, value, key));
                keyMp[key] = freqMp[freq + 1].begin();
                return value;
            }
        }
    }
    
    void put(int key, int value) {
        if(m_capacity == 0) return;
        if(!keyMp.count(key)) {
            if(m_size == m_capacity) {
                auto node = freqMp[minfreq].back();
                keyMp.erase(node.key);
                freqMp[minfreq].pop_back();
                if(freqMp[minfreq].size() == 0) freqMp.erase(minfreq);
                --m_size;
            }
            freqMp[1].push_front(LFUnode(1, value, key));
            keyMp[key] = freqMp[1].begin();
            minfreq = 1;
            ++m_size;
        }
        else {
            auto it = keyMp[key];
            int freq = it->freq;
            freqMp[freq].erase(it);
            if(freqMp[freq].size() == 0) {
                freqMp.erase(freq);
                if(minfreq == freq) minfreq += 1;
            }
            freqMp[freq + 1].push_front(LFUnode(freq + 1, value, key));
            keyMp[key] = freqMp[freq + 1].begin();
        }

    }
};