LRU缓存机制

class LRUCache {
    struct DLinkedNode {
        int key;
        int value;
        DLinkedNode* prev;
        DLinkedNode* next;
        DLinkedNode() : value(0), prev(nullptr), next(nullptr) {}
    };

private:
    unordered_map<int, DLinkedNode*> cache;
    DLinkedNode* head;
    DLinkedNode* tail;
    int size;
    int capacity;

private:
    void addToHead(DLinkedNode* node) {
        if (nullptr != node && nullptr != head && nullptr !=head->next) {
            node->next = head->next;
            node->prev = head;
            head->next->prev = node;
            head->next = node;
        }
    }

    void remove(DLinkedNode* node) {
        if (nullptr != node && nullptr != node->next && nullptr != node->prev) {
            node->prev->next = node->next;
            node->next->prev = node->prev;
        }
    }

public:
    LRUCache(int _capacity) : capacity(_capacity), size(0) {
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head->next = tail;
        tail->prev = head;
    }

    int get(int key) {
        if (cache.count(key) && nullptr != cache.at(key)) {
            /* Shift it to List head to mark it as recently used*/
            DLinkedNode* node = cache.at(key);
            remove(node);

            /*make it as RU*/
            addToHead(node);

            return cache.at(key)->value;
        } else {
            return -1;
        }
    }

    void put(int key, int value) {
        DLinkedNode* node = nullptr;
        if (!cache.count(key)) {
            node = new DLinkedNode();
            cache[key] = node;
            ++size;
        } else {
            node = cache.at(key);
            delete (node);
        }

        // update node value and key
        node->value = value;
        node->key = key;
        // shift node as head
        addToHead(node);
        if (size > capacity) {
            DLinkedNode* node = tail->prev;
            remove(node);
            cache.erase(node->key);
            // 防止内存泄漏
            delete node;
            --size;
        }
    }
};

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