LeetCode146 LRU缓存机制

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

使用一个哈希表记录key，用双链表记录key，value和顺序。哈希表中key对应的是双链表节点的指针。每次查询就把当前节点移动到链表的头部。每次put的时候也会把put的节点移动到头部，同时判断是否超出capacity，如果超出就删除dummyhead前面的一个节点。

注意delete释放空间，修改指针要修改全。

链表双向主要是可以在O(1)时间内找到需要删除的节点（即dummyTail前一个节点）。节点需要记录key主要是删除的时候得到key，这样才能在O(1)时间内在哈希表中找到并删除。

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

struct LRU_Node {
    int key;
    int value;
    LRU_Node* next;
    LRU_Node* prev;
    LRU_Node() : key(0), value(0), next(nullptr), prev(nullptr) {}
    LRU_Node(int _key, int _value) :key(_key), value(_value), next(nullptr), prev(nullptr) {}
};

class LRUCache {
private:
    int num;
    int capacity;
    unordered_map<int, LRU_Node*> map_LRU;
    LRU_Node* dummyHead;
    LRU_Node* dummyTail;

public:
    LRUCache(int _capacity) {
        num = 0;
        capacity = _capacity;
        dummyHead = new LRU_Node(-1, -1);
        dummyTail = new LRU_Node(-1, -1);
        dummyHead->next = dummyTail;
        dummyTail->prev = dummyHead;
        map_LRU.clear();
        cout << "LRUCache is created.
";
    }

    LRU_Node* moveToHead(LRU_Node* cur) {
        cur->prev->next = cur->next;
        cur->next->prev = cur->prev;
        cur->next = dummyHead->next;
        cur->prev = dummyHead;
        dummyHead->next = cur;
        cur->next->prev = cur;
        return cur;
    }

    LRU_Node* insertHead(LRU_Node* new_node) {
        new_node->next = dummyHead->next;
        new_node->prev = dummyHead;
        dummyHead->next = new_node;
        new_node->next->prev = new_node;
        return new_node;
    }

    int get(int key) {
        if (map_LRU.find(key) != map_LRU.end()) {
            LRU_Node* cur = map_LRU[key];
            cur = moveToHead(cur);
            map_LRU[key] = cur;
            return cur->value;
        }
        return -1;
    }

    void put(int key, int value) {
        if (map_LRU.find(key) != map_LRU.end()) {
            LRU_Node* cur = map_LRU[key];
            cur->value = value;
            cur = moveToHead(cur);
            map_LRU[key] = cur;
        }
        else {
            LRU_Node* new_node = new LRU_Node(key, value);
            new_node = insertHead(new_node);
            map_LRU[key] = new_node;
            if (num != capacity)
                ++num;
            else {
                int deleteKey = dummyTail->prev->key;
                LRU_Node* toBeDelete=dummyTail->prev;
                dummyTail->prev=dummyTail->prev->prev;
                dummyTail->prev->next=dummyTail;
                delete toBeDelete;
                toBeDelete=nullptr;
                auto it = map_LRU.find(deleteKey);
                map_LRU.erase(it);
            }
        }
        return;
    }
};

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