146. LRU Cache

题目描述：为最近最少使用缓存LRU Cache设计数据结构，它支持两个操作：get和put。

• get(key)：如果key在cache中，则返回对应的value值，否则返回-1

• set(key,value)：如果key不在cache中，则将该(key,value)插入cache中（注意，如果cache已满，则必须把最近最久未使用的元素从cache中删除）；如果key在cache中，则重置value的值。

要求两操作的时间复杂度都为O(1)。如：

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

分析：LRU是操作系统中内存页面置换算法，Cache算法和内存页面置换算法的核心思想是一样的：都是在给定一个限定大小的空间的前提下，设计一个原则如何来更新和访问其中的元素。LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。如大小为4的cache传入序列为A B C D E D F：

若用数组处理，由于每个值还要加上时间戳，故每次插入新值都要将所有已存在的元素的时间戳加1，时间复杂度O(n)。
采用链表加哈希表的方法，插入新数据项时，若新数据项在链表中存在，则把该结点移到链表头部，若不存在，则新建一个结点，加到链表头部。若缓存满了，则把链表最后一个结点删除。访问数据时，若数据项在链表中存在，则把该结点移到链表头部，否则返回 -1 。这样链表尾部的结点就是最近最久未访问的数据项。时间复杂度O(1)，空间O(n)。
其中list 的splice函数的用法：

• void splice (iterator position, list& x);
  //将列表x中的所有元素移到当前list中，从当前列表的position指向的位置开始，操作后列表x为空

• void splice (iterator position, list& x, iterator i); //将列表x中迭代器 i 指向的元素移到当前list的position指向的位置处，操作后 i 指向的元素从列表x中被移除，所以迭代器 i 此时是invalid的；position是当前列表的迭代器，i是列表x的迭代器

• void splice (iterator position, list& x, iterator first, iterator last);
  //将列表x中[first, last)的元素移到当前list中，从position指向的位置开始；first, last是列表x的迭代器
  代码：

class LRUCache {
private:
    //cache结点的结构，一键一值
    struct CacheNode{
        int key;
        int val;
        CacheNode(int k, int v):key(k), val(v){}
    };
    //LRUCache的属性，一个链表一个哈希表
    list cacheList;        //cache结点的列表
    unordered_map::iterator> cacheMap;          //哈希表的值是结点的键，值是链表迭代器
    int capacity;            //cache大小
    
public:
    //初始化cache大小
    LRUCache(int capacity) {
        this -> capacity = capacity;
    }
    //查找
    int get(int key) {
        if (cacheMap.find(key) == cacheMap.end()) return -1;
        //将要访问的结点移到链表头
        cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
        cacheMap[key] = cacheList.begin();
        return cacheMap[key] -> val;
    }
    //插入
    void put(int key, int value) {
        if (cacheMap.find(key) == cacheMap.end())
        {  //没找到，首先要判断链表是否已满
            if (cacheList.size() == capacity)
            {  //先在哈希表中删除链表的尾结点的键对应的迭代器，再在链表尾删除此结点
                cacheMap.erase(cacheList.back().key);
                cacheList.pop_back();
            }
            //将该结点插到表头，再在哈希表中加入其迭代器
            cacheList.push_front(CacheNode(key, value));
            cacheMap[key] = cacheList.begin();
        }
        else         //找到，更新其值且将该结点移到链表头，最后更新哈希表的值——该键的迭代器，为表头迭代器
        {
            cacheMap[key] -> val = value;
            cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
            cacheMap[key] = 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);
 */