leetcode——第146题——LRU缓存机制

题目：
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

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

/*
哈希表保证了查询的 时间复杂度为 O(1)
双向链表保证了 时间顺序，链表便于插入和删除操作

当 有新数据插入put 或 发生查询get 时，将键值对移动到链表的首部，并更新哈希对应的迭代器索引
这样就保证了当 出发 LRU 淘汰时，只需要从序列尾部进行数据删除即可

哈希映射 <key, node>
这个node是自己定义的一个类，是一个自己实现的双向链表结构
因为是自己实现的双向链表，所以要在 LURCache 中多很多自己实现的函数
*/
struct DListNode{
    int key, value;
    DListNode* prev;
    DListNode* next;
    DListNode() : key(0), value(0), prev(nullptr), next(nullptr) {};
    DListNode(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {};
};
class LRUCache {
public:
    LRUCache(int capacity) : cap(capacity), size(0) {
        // cap 和 size 在初值列中进行初始化
        // 虚拟头结点和虚拟尾结点在这里进行初始化并进行定义
        head = new DListNode();     // 已经定义过了，所以直接用就可以
        tail = new DListNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if (mp.count(key) == 0) return -1;
        moveToHead(mp[key]);
        return mp[key]->value;
    }
    
    void put(int key, int value) {
        if (mp.count(key) == 0)
        {
            // 如果不存在，创建一个节点，但是需要先判断是否达到容量
            if (size >= cap)
            {
                // 这里就表明了为什么在删除节点的时候，需要一个返回值，因为要通过这个返回值，把哈希中的值也删掉
                DListNode* temp = removeTail();
                mp.erase(temp->key);    // 这里表明了为什么 链表中出来 value外 还需要一个 key
                delete temp;    // 防止内存泄漏，写在了这里有点怪异
                --size;
            }
            DListNode* node = new DListNode(key, value);
            addToHead(node);    // 1、加入到 链表中
            mp[key] = node;     // 2、加入到 哈希映射
            ++size;             // 3、大小 ++
            return;
        }
        // 先找到那个节点，怎么找节点呢？ 得通过哈希呀
        DListNode* node = mp[key];
        node->value = value;    // 1、改变值
        moveToHead(node);       // 2、移动到前面，这一步容易忘记
    }



/****************************************************************************************/
private:
    unordered_map<int, DListNode*> mp;   // <key, 双向链表>
    DListNode* head;  // 虚拟头结点，也就是并不是真实的节点，方便操作
    DListNode* tail;  // 尾结点，也不是真是存在的节点，方便操作
    int size;   // 这个是干嘛的呢？ // 明白了，size用来计数，每新增加一个节点，计数 +1
    int cap;    // 这个是存储容量的

    // 在头部增加节点
    void addToHead(DListNode* node)
    {
        node->prev = head;  // 连接 node 的prev
        node->next = head->next;    // 连接node的next
        head->next->prev = node;    // 把原来真正的节点的 prev 连给 node
        head->next = node;      // 把虚拟头结点指向 node
    }

    // 删除节点操作，删除任意节点
    void removeNode(DListNode* node)
    {
        node->prev->next = node->next;
        node->next->prev = node->prev;
        // delete node;    // 防止内存泄漏
    }

    // 将某个已经存在的节点，移动到首部
    void moveToHead(DListNode* node)
    {
        removeNode(node);
        addToHead(node);
    }

    DListNode* removeTail()
    {
        DListNode* node = tail->prev;   // 这里就通过虚拟尾结点简化了整个操作
        removeNode(node);
        return node;
    }
};

class LRUCache {
public:
    LRUCache(int capacity) : cap(capacity) {

    }
    void put(int key, int value)    // 头插，如果容量已经满了，需要先删除最后一个，哈希表只需要跟随链表同步变化即可
    {
        // 忘记判断是否存在了
        if (mp.count(key) == 0) // 不存在的话，直接插入。存在就可以之前替换
        {
            if (lrulist.size() == cap)
            {
                auto tmp = lrulist.back();
                mp.erase(tmp.first);
                lrulist.pop_back();
            }
            lrulist.push_front({key, value});
            mp[key] = lrulist.begin();
            return;
        }
        else 
        {
            auto iter = mp[key];

            lrulist.erase(iter);
            lrulist.push_front({key, value});
            mp[key] = lrulist.begin();
        }
    }
    int get(int key)    // 1.别忘了更新key 2.常数时间取值，所以要用哈希
    {
        if (mp.count(key) == 0)    return -1;   // 注意先判空，不然直接取 mp[key] 是可能报错的
        auto iter = mp[key];
        // 不能直接return，还需要更新到最前面
        int value = iter->second;
        lrulist.erase(iter);
        lrulist.push_front({key, value});
        mp[key] = lrulist.begin();
        return value;
    }    
private:
    int cap;    // 记录存储能力
    list<pair<int, int>> lrulist;
    unordered_map<int, list<pair<int, int>>::iterator> mp;    // 哈希表的value用来记录链表的迭代器
};

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