LRU 缓存机制c++ 哈希表+双向链表

#include <unordered_map>
struct DListNode{
    int key;
    int val;
    DListNode* prev;//前驱
    DListNode* next;//后继
    DListNode(): key(0), val(0), prev(nullptr), next(nullptr) {}
    DListNode(int _key,int _val): key(_key), val(_val), prev(nullptr), next(nullptr) {}
};

class Solution {
private:
    unordered_map<int, DListNode*> cache;
    DListNode* head;
    DListNode* tail;
    //最大容量
    int capacity;
public:
    Solution(){
        // 使用伪头部和伪尾部节点
        head = new DListNode();
        tail = new  DListNode();
        head->next = tail;
        tail->prev = head;
        capacity = 0;
    }
    vector<int> LRU(vector<vector<int> >& operators, int k) {
        // write code here
        vector<int> res;
        capacity = k;
        for(int i = 0;i<operators.size();i++){
            if(operators[i].size()==3){//set(x, y)
                set(operators[i][1],operators[i][2]);
            }else{
                res.push_back(get(operators[i][1]));
            }
        }
        return res;
    }
    int get(int key) {
        //查找不存在 返回-1
        if (!cache.count(key)) {
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        DListNode* node = cache[key];
        moveToHead(node);
        return node->val;
    }

    void set(int key, int value) {
        if (!cache.count(key)) {
            // 如果 key 不存在，创建一个新的节点
            DListNode* node = new DListNode(key, value);
            // 添加进哈希表
            cache[key] = node;
            // 添加至双向链表的头部
            addToHead(node);
            if (cache.size() > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                DListNode* removed = removeTail();
                // 删除哈希表中对应的项
                cache.erase(removed->key);
                // 防止内存泄漏
                delete removed;
            }
        }
        else {
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            DListNode* node = cache[key];
            node->val = value;
            moveToHead(node);
        }
    }

    void addToHead(DListNode* node) {
        //添加到链表头部
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

    void removeNode(DListNode* node) {
        //删除
        //前驱节点的后驱 = node的后驱
        //后驱节点的前驱 = node的前驱
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

    void moveToHead(DListNode* node) {
        //移动到头部
        removeNode(node);
        addToHead(node);
    }

    //删除尾端节点，并返回
    DListNode* removeTail() {
        DListNode* node = tail->prev;
        removeNode(node);
        return node;
    }
};