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

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路

思路就是官方题解中的双向链表+哈希表，其中双向链表中每个结点 Node 都内置了 key 和 val，同时结点是按照最近使用时间排序的，最近使用过的键值对放在最前面，最近最久未使用的放在最后面。哈希表用来快速定位 Node 的位置，通过 key 查询 Node 的指针。

为什么要用双向链表而不是单向链表？因为在链表中删除结点或者加入新节点都需要得到该结点前一个结点的指针（需要修改该结点的 next 指针），如果使用单向链表，那就需要 O(n) 的时间去找到前面那个结点，双向链表就没有这个问题了。

时间复杂度：$O(1)$
空间复杂度：$O(n)$

C++ 代码

class myNode {
public:
    int key;
    int val;
    myNode* prev;
    myNode* next;

    myNode()
        : key(0), val(0), prev(nullptr), next(nullptr) { }
    myNode(const int k, const int v)
        : key(k), val(v), prev(nullptr), next(nullptr) { }
};

class LRUCache {
public:
    LRUCache(const int cap)
        : capacity(cap), head(new myNode()), tail(new myNode()) {
        head->next = tail;
        tail->prev = head;
    }
    
    int get(const int key) {
        if (keyToNode.find(key) != keyToNode.end()) {
            myNode *p = keyToNode[key];
            moveToHead(p);
            return p->val;
        } else {
            return -1;
        }
    }
    
    void put(int key, int value) {
        if (keyToNode.find(key) != keyToNode.end()) {
            myNode *p = keyToNode[key];
            p->val = value;
            moveToHead(p);
        } else {
            if (keyToNode.size() == capacity) {
                deleteNode(tail->prev);
            }
            addToHead(key, value);
        }
    }

private:
    int capacity;
    myNode* head;
    myNode* tail;
    unordered_map<int, myNode*> keyToNode;

    void moveToHead(myNode* p) {
        // 摘下 p
        p->prev->next = p->next;
        p->next->prev = p->prev;
        // 移到链表头
        p->next = head->next;
        p->prev = head;
        head->next->prev = p;
        head->next = p;
    }

    void deleteNode(myNode* p) {
        p->prev->next = p->next;
        p->next->prev = p->prev;
        keyToNode.erase(p->key);
        delete p;
    }

    void addToHead(const int key, const int val) {
        // 链表头加入新结点
        myNode* newNode = new myNode(key, val);
        newNode->prev = head;
        newNode->next = head->next;
        head->next->prev = newNode;
        head->next = newNode;
        // 更新 keyToNode
        keyToNode[key] = newNode;
    }
};

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