C++怎么实现一个LRU缓存淘汰算法_C++结合哈希表与双向链表实现LRU Cache

struct Node { int key, value; Node prev, next; Node(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {} };

class LRUCache { private: unordered_map> cache; Node head; Node* tail; int capacity;

void removeNode(Node* node) {
    node-youjiankuohaophpcnprev-youjiankuohaophpcnnext = node-youjiankuohaophpcnnext;
    node-youjiankuohaophpcnnext-youjiankuohaophpcnprev = node-youjiankuohaophpcnprev;
}

void addToHead(Node* node) {
    node-youjiankuohaophpcnnext = head-youjiankuohaophpcnnext;
    node-youjiankuohaophpcnprev = head;
    head-youjiankuohaophpcnnext-youjiankuohaophpcnprev = node;
    head-youjiankuohaophpcnnext = node;
}

void moveToHead(Node* node) {
    removeNode(node);
    addToHead(node);
}

Node* removeTail() {
    Node* node = tail-youjiankuohaophpcnprev;
    removeNode(node);
    return node;
}

public: LRUCache(int cap) : capacity(cap) { head = new Node(0, 0); tail = new Node(0, 0); head->next = tail; tail->prev = head; }

int get(int key) {
    if (cache.find(key) == cache.end()) return -1;
    Node* node = cache[key];
    moveToHead(node);
    return node-youjiankuohaophpcnvalue;
}

void put(int key, int value) {
    if (cache.find(key) != cache.end()) {
        Node* node = cache[key];
        node-youjiankuohaophpcnvalue = value;
        moveToHead(node);
    } else {
        Node* newNode = new Node(key, value);
        cache[key] = newNode;
        addToHead(newNode);

        if (cache.size() youjiankuohaophpcn capacity) {
            Node* removed = removeTail();
            cache.erase(removed-youjiankuohaophpcnkey);
            delete removed;
        }
    }
}

~LRUCache() {
    for (auto& pair : cache) {
        delete pair.second;
    }
    delete head;
    delete tail;
}

};