146.LRU缓存【leetcode】3/100

题目：146.LRU缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 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

热度：3/100

代码：

//官方做法：思路非常清晰
//时间复杂度：对于 put 和 get 都是 O(1)。
//空间复杂度：O(capacity)，因为哈希表和双向链表最多存储capacity+1个元素。

//双向链表节点
struct DlinkedNode{
    int key, value;
    DlinkedNode* prev;
    DlinkedNode* next;
    DlinkedNode():key(0),value(0),prev(nullptr),next(nullptr){}
    DlinkedNode(int _key, int _value):key(_key),value(_value),prev(nullptr),next(nullptr){}
};

class LRUCache {
private:
    unordered_map<int,DlinkedNode*> cache;  //key: 要get的值，value:该值对应的链表节点是哪个
    DlinkedNode* head;  //伪头节点
    DlinkedNode* tail;  //伪尾节点
    int size;           //LRU缓存中实际的数量
    int capacity;       //LRU缓存中的容量
public:
    //LRU缓存的初始化
    LRUCache(int capacity) {
        this->capacity = capacity;
        size = 0;
        //使用伪头部和伪尾部节点
        head = new DlinkedNode();
        tail = new DlinkedNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        //要查找的值不存在，返回-1
        if(!cache.count(key)){
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        DlinkedNode* node = cache[key];
        moveToHead(node);
        return node->value;
    }
    
    void put(int key, int value) {
        if(!cache.count(key)){
            // 如果 key 不存在，创建一个新的节点
            DlinkedNode* node = new DlinkedNode(key,value);
            // 添加到哈希表
            cache[key] = node;
            // 添加至双向链表的头部
            addToHead(node);
            ++size;
            if(size>capacity){
                // 如果超出容量，删除双向链表的尾部节点
                DlinkedNode* removed = removeTail();
                // 删除哈希表中对应的项
                cache.erase(removed->key);
                // 防止内存泄漏
                delete removed;
                --size;
            }
        }else{
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            DlinkedNode* node = cache[key];
            node->value = value;
            moveToHead(node);
        }
    }

    //将node节点添加到链表的首部(伪头节点head的下一个节点位置)
    void addToHead(DlinkedNode* node){
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

    //将node节点从链表中移除
    void removeNode(DlinkedNode* node){
        node->prev->next = node->next;  //将node节点的前向指针的下一个节点 指向node节点的下一个节点
        node->next->prev = node->prev;  //将node节点的下一个节点的前向指针 指向node节点的上一个节点
    }
    //将节点node移动到链表头部
    void moveToHead(DlinkedNode* node){
        //先将node节点从链表中移除
        removeNode(node);
        //然后将node节点添加到
        addToHead(node);
    }

    //删除双向链表的尾部节点
    DlinkedNode* removeTail(){
        DlinkedNode* node = tail->prev; //获取伪尾节点的上一个节点，即双向链表中实际的尾节点
        removeNode(node);               //将尾节点移除
        return node;                    //返回移除的尾节点
    }
};

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