LRU Cache

Problem:

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.

分析：

先用例子回顾LRU调度算法，假设内存中页面容量是3，而共有6页，编号依次为1至6。现在有十次页面调用，依次为1, 3, 1, 2, 4, 5, 3, 4, 6, 1。首先假设内存中空，内存中页面的替换顺序为

(1) 1

(2) 3, 1

(3) 1, 3

(4) 2, 1, 3

(5) 4, 2, 1

(6) 5, 4, 2

(7) 3, 5, 4

(8) 4, 3, 5

(9) 6, 4, 3

(10) 1, 6, 4

十次页面调用中，除去第(3)(8)两次外，均发生了缺页中断。观察以上的序列调用情况，整体上页面被组织成了一个队列形式，刚刚使用的页面放在队尾，而每次被替换出去的页面都放在队头。如果没有缺页中断，页面在内存中，也要将刚刚访问的页面放在队尾。在内存容量没有到达前，所有的缺页中断均将页面直接接在队尾。

以上的分析能够看出，页面的替换算法中涉及了很多的元素顺序调整，也就是队列中的移除与插入操作，所以使用链表可以降低时间开销。然而，检测访问页面是否在内存中是较耗时的操作，为了加速访问效率，可以用map加速查找。

双向队列可以方便删除与插入操作，使用哨兵能够让代码变得简洁，所以综上，采用带哨兵的双向链表与map结合，能够达到较好的代码编写难度与效率的平衡。map使用了红黑树的结构，可以保证get与set操作的平均时间复杂度在O(log n)。

struct CacheBlock {
    int key;
    int value;
    CacheBlock *prev;
    CacheBlock *next;
    
    CacheBlock(int k, int v) : key(k), value(v), prev(NULL), next(NULL) {}
};

class LRUCache{
    CacheBlock *list; // doubly list with sentinel
    int capacity;
    int size;
    map<int, CacheBlock*> caches;
    
public:
    LRUCache(int cap) : list(NULL), capacity(cap), size(0) {
        // initialize sentinel
        list = new CacheBlock(-1, -1);
        list->prev = list->next = list;
    }
    
    ~LRUCache() {
        if(list) {
            delete list;
            list = NULL;
        }
    }
    
    int get(int key) {
        if(caches.find(key) == caches.end())
            return -1;
        else
            return caches[key]->value;
    }
    
    void set(int key, int value) {
        if(caches.find(key) == caches.end()) { // page fault
            if(size < capacity) {
                // add head
                CacheBlock *cb = new CacheBlock(key, value);
                insert(cb);
                caches[key] = cb;
                ++size;
            } else {
                // remove tail
                CacheBlock *tail = list->prev;
                remove(tail);
                caches.erase(tail->key);
                // add head
                tail->key = key;
                tail->value = value;
                tail->next = tail->prev = NULL;
                insert(tail);
                caches[key] = tail;
            }
        } else {
            // find page
            CacheBlock *cb = caches[key];
            // remove page
            remove(cb);
            // add head
            cb->value = value;
            cb->next = cb->prev = NULL;
            insert(cb);
        }
    }
    
    void insert(CacheBlock *cb) {
        // insert to front of the list
        cb->next = list->next;
        list->next->prev = cb;
        list->next = cb;
        cb->prev = list;
    }
    
    void remove(CacheBlock *cb) {
        cb->prev->next = cb->next;
        cb->next->prev = cb->prev;
    }
};