LeetCode 146 LRU緩存機制 C++版本

LRU緩存機制

運用你所掌握的數據結構，設計和實現一個 LRU (最近最少使用) 緩存機制。它應該支持以下操作： 獲取數據 get 和 寫入數據 put 。

獲取數據 get(key) - 如果關鍵字 (key) 存在於緩存中，則獲取關鍵字的值（總是正數），否則返回 -1。
寫入數據 put(key, value) - 如果關鍵字已經存在，則變更其數據值；如果關鍵字不存在，則插入該組「關鍵字/值」。當緩存容量達到上限時，它應該在寫入新數據之前刪除最久未使用的數據值，從而爲新的數據值留出空間。

進階:

你是否可以在 O(1) 時間複雜度內完成這兩種操作？

示例

LRUCache cache = new LRUCache( 2 /* 緩存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 該操作會使得關鍵字 2 作廢
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 該操作會使得關鍵字 1 作廢
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

分析

分析上面的操作過程，要讓 put 和 get 方法的時間複雜度爲 O(1)，我們可以總結出 這個數據結構必要的條件：查找快，插入快，刪除快，有順序之分
新的數據結構必須有順序之分，以區分最近使用的和久未使用的數據；而且我們要在 數據結構中查找鍵是否已存在；如果容量滿了要刪除最後一個數據；每次訪問還要把數據插入到隊頭。
看到Key-value 對應關係 第一點想到的是要用到哈希表，這點應該沒有異議，因爲哈希表滿足查找數據時間複雜度O(1)的要求，在這點上，vector也是可以滿足要求，但是難就難在第二點要求了，插入和刪除也得滿足O(1)要求這時候vector就不行了，只能考慮到雙向鏈表，所以現在初步定下來就是哈希表+雙向鏈表的組合了。
就是藉助哈希表賦予了鏈表快速查找的特性：可以快速查找某個 key 是否存在緩存（鏈表）中，同時可以快速刪除、添加節點。回想剛纔的例子，這種數據結構是不是完美解決了 LRU 緩存的需求

struct Node
{
    int key;
    int value;
    Node* pre;
    Node* next;
    // 構造函數初始化
    Node(int key, int value) : key(key), value(value), pre(nullptr), next(nullptr){}
};

class LRUCache {
private:
    int size;// 緩衝區大小
    Node* head;
    Node* tail;
    map<int, Node*> p;

public:
    LRUCache(int capacity) {
        this->size = capacity;
        head = nullptr;
        tail = nullptr;
    }
// 獲取緩衝區中 key 對應的 value
    int get(int key) {
        // 1.當該 key 值存在
        if(p.count(key) > 0)
        {
            // 刪除該 key 對應的原來節點
            Node* cur = p[key];
            int value = cur->value;
            remove(cur);   // 這裏僅僅刪除哈希雙向鏈表中的節點，不必刪除哈希表中的                 
            // 將節點重現插入到緩衝區的頭部
            setHead(cur);                     
            return value;
        }
        // 2.當該 key 值不存在
        return -1;
    }
// 將key-value值存入緩衝區
    void put(int key, int value) {
        // 1.當該 key 值存在
        if(p.count(key) > 0)
        {
            // 刪除該 key 對應的原來節點
            Node* cur = p[key];
            cur->value = value;
            remove(cur);    // 這裏僅僅刪除哈希雙向鏈表中的節點，不必刪除哈希表中的                                
            // 將節點重現插入到緩衝區的頭部
            setHead(cur);
        }
        else// 2.當該 key 值不存在
        {
            Node* node = new Node(key, value);
            // 判斷當前緩衝區大小已經滿了
            if(p.size() >= size)
            {
                // 刪除尾部節點
                map<int, Node*>::iterator it = p.find(tail->key);// 返回迭代器類型
                remove(tail);
                p.erase(it);
                setHead(node);
                p[key] = node;// 這裏erase 函數參數是迭代器類型，所以上面需要使用迭代器類型
                // 將新節點插入到緩衝區的頭部
            }
            else 
            //還沒有滿：將新節點插入到緩衝區的頭部
            {
                setHead(node);
                p[key] = node;
            }
        }
    }

    // 刪除當前節點
    void remove(Node* cur)
    {
        // 當前節點是 head
        if(cur == head)
            head = cur->next;
        else if(cur == tail)// 當前節點是 tail
            tail = cur->pre;
        else// 當前節點是一般節點
        {
            cur->pre->next = cur->next;
            cur->next->pre = cur->pre;
        }
    }
    // 將當前節點插入到頭部
    void setHead(Node* cur)
    {
        cur->next = head;
        if(head != nullptr)
            head->pre = cur;
        head = cur;//重現更新head

        if(tail==nullptr)
            tail = head;
    }
};

疑問

爲什麼要是雙向鏈表，單鏈錶行不行？另外，既然哈希表中已經存了 key，爲什麼鏈表中還要存鍵值對呢，只存值不就行了？
對於問題1 刪除鏈表的代碼裏我們能看出爲什麼

因爲我們需要刪除操作。刪除一個節點不光要得到該節點本身的指針，也需要操作其前驅節點的指針，而雙向鏈表才能支持直接查找前驅，保證操作的時間複雜度 O(1)。

對於問題2

當緩存容量已滿，我們不僅僅要刪除最後一個 Node 節點，還要把 map 中映射到該節點的 key 同時刪除，而這個 key 只能由 Node 得到。如果 Node 結構中只存儲 val，那麼我們就無法得知 key 是什麼，就無法刪除 map 中的鍵，造成錯誤。