LeetCode 146 LRU缓存机制

题目描述
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。实现 LRUCache 类：
LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：
输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

清华操作系统视频

由于出栈入栈时间复杂度比较高，因此使用双链表来存储页面，hash表来保存键值对。

• 当插入新入的页面时需要判断该页面是否在双链表中存在，如果存在删除该页面并插入到链表最前面，插入的时候双链表超过了cache给定的cache的大小，那么需要删除最后的页面，需要删除双链表中最后一个页面且hash表中对应的键值对也要删除。
• 当访问一个页面时，如果该页面不存在，那么返回-1，如果该页面存在需要返回该页面的值，需要注意的是访问了该页面需要删除该页面并且放到双链表最前面。因为访问一个页面意味着该页面也是被操作过的。

class LRUCache {
public:
    struct Node{
        int key,val;
        Node *left,*right;
        Node(int _key,int _val):key(_key),val(_val),left(NULL),right(NULL){}
    }*L,*R;
    unordered_map<int,Node*> hash;
    int n;
    LRUCache(int capacity) {
        n = capacity;
        L = new Node(-1,-1),R = new Node(-1,-1);
        L->right=R,R->left=L;//初始情况只有左右两个节点，需要互相指向对方
    }
    void remove(Node *p)
    {
        p->left->right=p->right;
        p->right->left=p->left;    
    }
    void insert(Node *p)
    {
        p->right=L->right;
        p->left=L;
        L->right->left=p;
        L->right=p;
    }

    int get(int key) {
    //如果得到节点需要将节点删除移动到链表首部
        if(hash.count(key)==0) return -1;
        auto p = hash[key];
        remove(p);
        insert(p);
        return p->val;
    }
    
    void put(int key, int value) {
    //要找的节点存在，则修改值，移除节点，插入到链表首部
        if(hash.count(key))
        {
            auto p = hash[key];
            p->val=value;
            remove(p);
            insert(p);
        }
        else 
        {
        //超出容量之后删除尾部的节点，并且删除hash表中的节点
            if(hash.size()==n) 
            {
                auto p = R->left;
                remove(p);
                hash.erase(p->key);
                delete p;
            }
            //反之创建节点，hash中创建节点，且插入到链表首部
            auto p = new Node(key,value);
            hash[key]=p;
            insert(p);
        }
    }
};

/**
 * 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);
 */