亲自操刀：cache页面置换算法LRU AND LFU

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get andput.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(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.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LRUCache cache = new LRUCache( 2 /* capacity */ );cache.put(1, 1);cache.put(2, 2);cache.get(1);       // returns 1cache.put(3, 3);    // evicts key 2cache.get(2);       // returns -1 (not found)cache.put(4, 4);    // evicts key 1cache.get(1);       // returns -1 (not found)cache.get(3);       // returns 3cache.get(4);       // returns 4 

class LRUCache {private:    typedef list<int> LI; //双向链表，已知数据指针的情况下，删除和插入到链表头的时间都为O(1)。用STL中的list实现，    typedef pair<int,LI::iterator> PII;//哈希表中key->value的结构为hash[key]=(value,iterator)    typedef unordered_map<int,PII> HASH;    LI cachelist;    HASH mp;    int _capacity;public:    LRUCache(int capacity) :_capacity(capacity){            }        int get(int key) {        if(mp.count(key)){            int value=mp[key].first;            cachelist.erase(mp[key].second);            cachelist.push_front(key);            mp[key].second=cachelist.begin();            return value;        }else{            return -1;        }    }        void put(int key, int value) {        if(mp.count(key)){            mp[key].first=value;            cachelist.erase(mp[key].second);            cachelist.push_front(key);            mp[key].second=cachelist.begin();        }else{            if(cachelist.size()==_capacity){                LI::iterator it=cachelist.end();--it;                int delkey=*it;                cachelist.erase(it);                mp.erase(delkey);            }//这里千万别用else，否则链表满了的时候不会再插入新key。                        cachelist.push_front(key);            mp[key].first=value;            mp[key].second=cachelist.begin();                    }            }};/** * Your LRUCache object will be instantiated and called as such: * LRUCache obj = new LRUCache(capacity); * int param_1 = obj.get(key); * obj.put(key,value); */

Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and put.
get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.
Follow up:
Could you do both operations in O(1) time complexity?
Example:
LFUCache cache = new LFUCache( 2 /* capacity */ );cache.put(1, 1);cache.put(2, 2);cache.get(1);       // returns 1cache.put(3, 3);    // evicts key 2cache.get(2);       // returns -1 (not found)cache.get(3);       // returns 3.cache.put(4, 4);    // evicts key 1.cache.get(1);       // returns -1 (not found)cache.get(3);       // returns 3cache.get(4);       // returns 4

class LFUCache {public:    LFUCache(int capacity) {        cap = capacity;    }        int get(int key) {        if (m.count(key) == 0) return -1;        freq[m[key].second].erase(iter[key]);        ++m[key].second;        freq[m[key].second].push_back(key);        iter[key] = --freq[m[key].second].end();        if (freq[minFreq].size() == 0) ++minFreq;        return m[key].first;    }        void put(int key, int value) {        if (cap <= 0) return;        if (get(key) != -1) {            m[key].first = value;            return;        }        if (m.size() >= cap) {            m.erase(freq[minFreq].front());            iter.erase(freq[minFreq].front());            freq[minFreq].pop_front();        }        m[key] = {value, 1};        freq[1].push_back(key);        iter[key] = --freq[1].end();        minFreq = 1;    }private:    int cap, minFreq;    unordered_map<int, pair<int, int>> m;//key->(value,f)    unordered_map<int, list<int>> freq;//freq->list    unordered_map<int, list<int>::iterator> iter;//key->iter};