LeetCode146：LRU Cache

题目：

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

解题思路：

利用双向链表+hashtable实现

Cache中的存储空间往往是有限的，当Cache中的存储块被用完，而需要把新的数据Load进Cache的时候，我们就需要设计一种良好的算法来完成数据块的替换。LRU的思想是基于“最近用到的数据被重用的概率比较早用到的大的多”这个设计规则来实现的。

为了能够快速删除最久没有访问的数据项和插入最新的数据项，我们双向链表连接Cache中的数据项，并且保证链表维持数据项从最近访问到最旧访问的顺序。每次数据项被查询到时，都将此数据项移动到链表头部（O(1)的时间复杂度）。这样，在进行过多次查找操作后，最近被使用过的内容就向链表的头移动，而没有被使用的内容就向链表的后面移动。当需要替换时，链表最后的位置就是最近最少被使用的数据项，我们只需要将最新的数据项放在链表头部，当Cache满时，淘汰链表最后的位置就是了。
    查找一个链表中元素的时间复杂度是O(n)，每次命中的时候，我们就需要花费O(n)的时间来进行查找，怎么样才能提高查找的效率呢？当然是hashtable了，因为它的查找时间复杂度是O(1)。

实现代码：

#include <iostream>

#include <unordered_map>



using namespace std;

/*

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.



get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.

set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

*/



//双向链表节点 

struct LRUNode

{

    int key;

    int val;

    LRUNode *pre;

    LRUNode *next;

    LRUNode(int k = 0, int v = 0):key(k), val(v),pre(NULL), next(NULL){

    } 

};

class LRUCache{

public:

    LRUCache(int capacity):cap(capacity),size(0) {

        head = new LRUNode();

        tail = new LRUNode();

        head->next = tail;

        tail->pre = head;

             

    }

    

    int get(int key) {

        LRUNode *t = hashtable[key];

        if(t)//key在hashtable存在，则调整该key在链表中对应节点的位置，将其插入到最前面 

        {

            //分离t节点 

            t->pre->next = t->next;

            t->next->pre = t->pre;

            //将t节点插入到头结点之后，即第一个数据节点 

            t->pre = head;

            t->next = head->next;

            head->next = t;

            t->next->pre = t;

            return t->val;

            

        }

        else

            return -1;

        

    }

    

    void set(int key, int value) {

        LRUNode *t = hashtable[key];

        if(t)//key在hashtable存在，则更新value及调整该key对应节点在链表中位置，将其插入到第一个节点 

        {

            t->val = value;

            //分离t节点 

            t->pre->next = t->next;

            t->next->pre = t->pre;

            //将t节点插入到头结点之后，即第一个数据节点

            t->pre = head;

            t->next = head->next;

            head->next = t;

            t->next->pre = t;

            return ;

            

        }



        if(size == cap)//如果双向链表容量已满即缓存容量已满，则将最近不使用的节点即链表最后一个数据节点删除 

        {

            LRUNode *tmp = tail->pre;

            tail->pre->pre->next = tail;           

            tail->pre = tmp->pre;

            hashtable.erase(tmp->key);

            delete tmp;

            size--;

        }

        

        //创建key对应的一个新节点，插入到最前面 

        LRUNode *node = new LRUNode(key, value);

        

        node->pre = head;

        node->next = head->next;

        head->next = node;

        node->next->pre = node;

        

        hashtable[key] = node;//在hashtable添加key对应的表项 

        

        size++;//链表节点数++ 

        

        

    }

private:

    int cap;//链表容量即缓存容量 

    int size;//缓存当前使用量 

    LRUNode *head;//链表头结点，不存数据， 

    LRUNode *tail;//链表尾节点，不存数据 

    unordered_map<int,LRUNode*> hashtable;//hashtable，用作查找O(1)时间复杂度 

    

};

int main(void)

{

    LRUCache lrucache(3);

    lrucache.set(1,8);

    lrucache.set(2,9);

    lrucache.set(3,10);

    lrucache.set(4,11);

    cout<<lrucache.get(1)<<endl;

    cout<<lrucache.get(2)<<endl;

    cout<<lrucache.get(4)<<endl;



    

    return 0;

}