[LeetCode 146.] LRU 快取機制

阿新 • • 發佈：2021-07-26

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

解題思路

根據題目的提示，O(1) 時間的 get/put 顯然是要使用 hashmap。然後我們繼續思考“最近最少”這個查詢條件的實現。
顯然這裡我們要維護一個訪問記錄的順序關係，使用連結串列是一個合理的思路。
那麼我們的設計也就呼之欲出了：

使用雙向連結串列維護訪問順序，越靠近 head 的說明訪問時間越近；
使用 hashmap 儲存 key 到 ListNode 的對映關係，用於在 O(1) 時間 get/put 操作；

到達容量上限時，從 tail 刪除元素；

參考程式碼

/*
 * @lc app=leetcode id=146 lang=cpp
 *
 * [146] LRU Cache
 */

// @lc code=start
class LRUCache {
    class DListNode {
      public:
        int key; // used to remove entry
        int val;
        DListNode *prev;
        DListNode *next;
        DListNode(int k = 0, int v = 0) : key(k), val(v), prev (nullptr), next (nullptr) {}
    };
private:
    unordered_map<int, DListNode*> cache;
    DListNode *head, *tail;
    int cap;
    int size;
public:
    LRUCache(int capacity) {
        cap = capacity;
        size = 0;
        head = new DListNode;
        tail = new DListNode;
        head->next = tail;
        tail->prev = head;
    }

    // int get(int key) Return -1 if the key not exists
    int get(int key) {
        if (cache[key]) {
            moveToHead(key);
            return cache[key]->val;
        } else {
            return -1;
        }
    }

    void put(int key, int value) {
        if (cache[key]) {
            moveToHead(key);
            cache[key]->val = value;
        } else {
            if (size < cap) {
                size ++;
                DListNode* p= new DListNode(key, value);
                addToHead(p);
                cache[key] = p;
            } else { // reuse object
                DListNode *p = removeFromTail();
                cache[p->key] = nullptr;
                addToHead(p);
                cache[key] = p;
                p->key = key;
                p->val = value;
            }
        }
    }
private:
    void moveToHead(int key) {
        // assert(cache.find(key));
        DListNode* p = cache[key];
        if (p->prev == head) return;
        p->prev->next = p->next;
        p->next->prev = p->prev;
        addToHead(p);
    }
    DListNode* removeFromTail() {
        // assert(tail->prev != head);
        DListNode* p = tail->prev;
        p->prev->next = tail;
        tail->prev = p->prev;
        return p;
    }
    void addToHead(DListNode* p) {
        p->next = head->next;
        head->next->prev = p;
        p->prev = head;
        head->next = 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);
 */
// @lc code=end