【LeetCode刷题（中等程度）】146. LRU缓存机制

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

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

进阶:

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

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得关键字 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得关键字 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：要在O(1)时间复杂度查找删除，那么底层数据结构肯定是哈希表，怎么表示节点的存在时间呢？可以利用链表来实现。所以本题我们实现一个双端链表来表示这些页在内存中的存在时间长短。

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


//使用链表记录缓存的使用时间
//实现将节点移动到头部的moveToHead函数功能
//实现将节点添加到头部的addToHead函数功能
//实现删除尾部节点的removeTail的函数功能
class LRUCache {
public:
    LRUCache(int capacity) {
        _capacity = capacity;
        _size = 0;
        
        //使用头部哨兵和尾部哨兵
        dummyHead = new LinkNode();
        dummyTail = new LinkNode();
        dummyHead->next = dummyTail;
        dummyTail->prev = dummyHead;
    }
    
    int get(int key) {
        if(mem_table.find(key) == mem_table.end())
            return -1;
        
        //如果key存在 就返回 因为已经访问过 则该节点要更新访问时间
        LinkNode* cur = mem_table[key];
        moveToHead(cur);
        return cur->value;
    }
    
    void put(int key, int value) {
        if(mem_table.find(key) == mem_table.end())
        {
            //如果key不存在 则创建一个新的节点
            LinkNode* node = new LinkNode(key,value);

            //添加到哈希表
            mem_table[key] = node;
            //添加到链表头部
            addToHead(node);
            ++_size;
            if(_size > _capacity)
            {
                //删除尾部节点
                LinkNode* node =  removeTail();
                //删除哈希表中对应的项
                mem_table.erase(node->key);
                
                delete node;
                --_size;
            }
        }
        else //如果已经存在 更新哈希表 ，并将当前节点移动到头节点
        {
           LinkNode* node =  mem_table[key];
           node->value = value;
           moveToHead(node);
        }
    }

public:
    void addToHead(LinkNode* node)
    {
        //注意连接顺序 首先完成Node的前向和后向连接
        node->prev = dummyHead;
        node->next = dummyHead->next;
        dummyHead->next->prev = node;
        dummyHead->next = node;
    }

    void removeNode(LinkNode* node)
    {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

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

    LinkNode* removeTail()
    {
        LinkNode* node = dummyTail->prev;
        removeNode(node);
        return node;
    }
private:
    unordered_map<int,LinkNode*> mem_table;
    unsigned int _size;
    unsigned int _capacity;
    LinkNode* dummyHead;
    LinkNode* dummyTail;
};

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