LRU cache实现

简单的链表实现

class LRUCache {
private:
    struct Node
    {
        Node *prev;
        Node *next;
        int key;
        int value;
        Node(int k,int v, Node* p = nullptr, Node *n = nullptr) :key(k),next(n), prev(p), value(v) {};
    };
public:
    LRUCache(int capacity) {
        maxCapacity = capacity;//最大容量
        size = 0;//当前cache中的结点数量
        head = nullptr;//头指针
        tail = nullptr;//尾指针
    }
    //取出key的值
    int get(int key) {
        //看看key是否在map中,map存放的是key所在结点的指针
        auto i = mapTable.find(key);
        if (i == mapTable.end())
            return -1;
        else
        {
            //在map中,将node从原先位置删除,移动到头部
            Node *node = (*i).second;
            removeNode(node);
            addNode(node);
            return node->value;
        }
    }

    void put(int key, int value) {
        auto i = mapTable.find(key);
        if (i == mapTable.end())
        {
            //检查是否超出容量
            if (size == maxCapacity)
            {
                Node *tmp = tail;
                removeNode(tail);
                mapTable.erase(tmp->key);
                delete tmp;
            }
            Node *node = new Node(key, value);
            addNode(node);
            mapTable[key] = node;
        }
        else
        {
            //在map中直接移动位置修改值即可
            Node *node = (*i).second;
            removeNode(node);
            addNode(node);
            node->value = value;
        }
    }
private:
    //添加node到头部
    void addNode(Node *node)
    {
        if (head == nullptr)
        {
            head = node;
            head->prev = nullptr;
            tail = node;
            tail->next = nullptr;
        }
        else
        {
            head->prev = node;
            node->next = head;
            node->prev = nullptr;
            head = head->prev;
        }
        ++size;
    }
    //从把node从原先位置删除
    void removeNode(Node *node)
    {
        if (node == head)
        {
            if (node->next == nullptr)
            {
                head = nullptr;
                tail = nullptr;
            }
            else
            {
                head = head->next;
                head->prev = nullptr;
            }
        }
        else if (node == tail)
        {
            tail = tail->prev;
            tail->next = nullptr;
        }
        else
        {
            node->prev->next = node->next;
            node->next->prev = node->prev;
        }
        --size;
    }
private:
    int maxCapacity;
    int size;
    Node *head;
    Node *tail;
    map<int, Node*> mapTable;
};

LRUCache cache = new LRUCache( 2 /* capacity */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // returns 1
cache.put(3, 3);    // evicts key 2
cache.get(2);       // returns -1 (not found)
cache.put(4, 4);    // evicts key 1
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4