LeetCode LRU Cache

class LRUCache{
private:
    int max_size;
    unordered_map<int, list<pair<int, int> >::iterator> hash;
    list<pair<int, int> > lru_stack;
public:
    LRUCache(int capacity) {
        if (capacity < 1) capacity = 0;
        max_size = capacity;
    }

    int get(int key) {
        unordered_map<int, list<pair<int, int> >::iterator>::iterator miter = hash.find(key);
        list<pair<int, int> >::iterator liter;
        if (miter == hash.end()) {
            return -1;
        } else {
            liter = miter->second;
            int val = liter->second;
            lru_stack.erase(liter);
            miter->second = liter = lru_stack.insert(lru_stack.begin(), make_pair(key, val));
            return liter->second;
        }
    }

    void set(int key, int value) {
        if (max_size == 0) return;
        unordered_map<int, list<pair<int, int> >::iterator>::iterator miter = hash.find(key);
        list<pair<int, int> >::iterator liter;
        if (miter == hash.end()) {   // key not exists in the cache
            if (hash.size() == max_size) {
                // invalidate LRU item to avoid overflow
                hash.erase(lru_stack.back().first);
                lru_stack.pop_back();
            }
            liter = lru_stack.insert(lru_stack.begin(), make_pair(key, value));
            hash.insert(make_pair(key, liter));
        } else {    // key already exists, so replace the value with new one
            liter = miter->second;
            lru_stack.erase(liter);
            miter->second = lru_stack.insert(lru_stack.begin(), make_pair(key, value));
        }
    }
};

用一个链表来维护LRU关系，map来做hash，用了std库，如果纯粹自己手工写可能会花多点时间

第二轮:

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.

最近在看Java集合发现LinkedHashMap自带LRU模式即使用LinkedHashMap(initialCapacity, loadFactor, accessOrder)构造函数指定accessOrder = true即使用访问顺序。不过本质上还是使用了hashmap加链表的形式来实现LRU过程。

import java.util.*;
public class LRUCache {
    private Map<Integer, Integer> storage;
    private int capacity;
    public LRUCache(int capacity) {
        storage = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true);
    
        this.capacity = capacity;
    }
    
    public int get(int key) {
        Integer value = storage.get(key);
        if (value == null) {
            return -1;
        }
        return value;
    }
    
    public void set(int key, int value) {
        boolean hasin = storage.keySet().contains(key);
        
        if (!hasin && capacity <= storage.size()) {
            Iterator<Map.Entry<Integer, Integer> > iter = storage.entrySet().iterator();
            Map.Entry<Integer, Integer> first = iter.next();
            storage.remove(first.getKey());
        }
        storage.put(key, value);
    }
}