LeetCode-146

LRU 缓存
简单说就是删除最久没有访问的节点

我们需要一个有序链表来记录节点，单向链表也可以，就是还要记录前驱后驱等，双向的可以省去很多中间变量。

//定义链表节点
struct Node
{
    int key, val;
    Node* pHead, * pTail;
    Node() : key(-1), val(-1), pHead(nullptr), pTail(nullptr) {}
    Node(int _key, int _val) : key(_key), val(_val), pHead(nullptr), pTail(nullptr) {}
};

class LRUCache
{
public:
    LRUCache(int capacity)
    {
        m_nCapacity = capacity;
        m_pLeft = new Node(), m_pRight = new Node();
        m_pLeft->pTail = m_pRight, m_pRight->pHead = m_pLeft;
    }

    ~LRUCache()
    {
        Node* pTemp = m_pLeft;
        if (m_pLeft)
        {
            pTemp = m_pLeft->pTail;
            delete m_pLeft;
            m_pLeft = pTemp;
        }
    }

    //这种指来指去的画个图就很容易理解了。
    //移除尾部元素，即最久未访问的
    void remove(Node* p)
    {
        p->pHead->pTail = p->pTail;
        p->pTail->pHead = p->pHead;
    }

    void insert(Node* p)
    {
        p->pTail = m_pLeft->pTail;
        m_pLeft->pTail->pHead = p;
        p->pHead = m_pLeft;
        m_pLeft->pTail = p;
    }


    int get(int key)
    {
        if (m_map.count(key) == 0)
        {
            return -1;
        }
        else
        {
            Node* pNode = m_map[key];
            remove(pNode);
            insert(pNode);
            return pNode->val;
        }
    }

    void put(int key, int value)
    {
        if (m_map.count(key))
        {
            Node* pNode = m_map[key];
            pNode->val = value;
            remove(pNode);
            insert(pNode);
        }
        else
        {
            if (m_map.size() == m_nCapacity)
            {
                Node* pNode = m_pRight->pHead;
                m_map.erase(pNode->key);
                remove(pNode);
                delete pNode;
            }
            Node* pNode = new Node(key, value);
            m_map[key] = pNode;
            insert(pNode);
        }
    }

private:
    Node* m_pLeft, * m_pRight;
    unordered_map<int, Node*> m_map;
    int m_nCapacity;
};