leetcode || 146、LRU Cache

problem：

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.

Hide Tags

 Data Structure

题意：实现LRU算法，题意没有详细说明怎么度量最近最少使用，难点所在

thinking：

（1）这道题我自己借助unordered_map和list实现了一个版本，小数据测试通过，大数据测试时(连续set、get)，由于频繁的操作map、list，超时了。

最高效的做法是将list嵌入到节点的结构体中。

        我的思路：构建一个包含key值和访问次数visited的结构体，每次访问结构体对象时，访问次数+1，在节点数未达到上限时，将新节点插入到list的头部。在达到上限时，

将访问次数最小的节点移到list的末尾，移除尾部节点，在list头部插入新的节点。使用unordered_map提高超找效率。

code：

class node{public:    int _key;    int _visited;    node(int key, int visited):_key(key),_visited(visited){}};class LRUCache{private:   unordered_map<int,list<node *>::iterator> map_record;    list<node *> list_record;    int size;public:    LRUCache(int capacity) {        size=capacity;    }    int get(int key) {        if(map_record.count(key)!=0)        {           unordered_map<int,list<node *>::iterator>::iterator it_a=map_record.find(key);            list<node *>::iterator it_b=it_a->second;            node *node_tmp=*it_b;            node_tmp->_visited+=1;            adjust();            return key;        }        else            return -1;    }    void set(int key, int value) {        if(map_record.count(key)!=0)        {           unoredered_map<int,list<node *>::iterator>::iterator it_a=map_record.find(key);            list<node *>::iterator it_b=it_a->second;            node *node_tmp=*it_b;            node_tmp->_key=value;            node_tmp->_visited+=1;        }        else        {            if(list_record.size()<size)            {                node *tmp_node=new node(value,1);                list_record.push_front(tmp_node);                list<node *>::iterator it=find(list_record.begin(),list_record.end(),tmp_node);                map_record.insert(make_pair(value,it));            }            else            {                adjust();               node *tmp_node=new node(value,1);               list_record.push_front(tmp_node);               map_record.clear();               for(list<node *>::iterator it=list_record.begin();it!=list_record.end();++it)               {                   node *tmp=*it;                   map_record.insert(make_pair(tmp->_key,it));                   }            }        }    }protected:    void adjust()    {        if(list_record.empty())            return;        node *index=list_record.back();        list<node *>::iterator min_it;        int min_visited=index->_visited;        for(list<node *>::iterator it=list_record.begin();it!=list_record.end();++it)        {            node *tmp_node = *it;            if(tmp_node->_visited<min_visited)                min_it=it;        }        list<node *>::iterator last=list_record.end();        swap(min_it,--last);        list_record.pop_back();    }};

一个高效且测试通过的版本：

struct CacheNode {    int key;    int value;    CacheNode* next;    CacheNode* prev;    CacheNode(int _key, int _value) {        key = _key;        value = _value;        next = nullptr;        prev = nullptr;    }};class LRUCache{public:    LRUCache(int capacity) {        _capacity = capacity;        head = new CacheNode(INT_MIN,-1);        tail = head->next;        len = 0;    }        int get(int key) {        auto found = cache.find(key);        if (found != cache.end()) {            if (found -> second == tail) {              tail = tail->prev;            }            insertToHead(found->second);            if (tail == head) tail = head -> next;            return found -> second -> value;        }        return -1;    }        void set(int key, int value) {        auto found = cache.find(key);        if (found != cache.end()) {            found->second->value = value;            if (found -> second == tail) {              tail = tail->prev;            }            insertToHead(found->second);            if (tail == head) tail = head->next;            return ;        }        if (len == _capacity) {            CacheNode* tmp = tail -> prev;            cache.erase(tail->key);            deleteNodeLink(tail);            delete tail;            tail = tmp;            insertToHead(new CacheNode(key, value));            return ;        }        insertToHead(new CacheNode(key, value));        if (tail == nullptr) tail = head->next;        len++;    }private:   CacheNode* head;   CacheNode* tail;   int _capacity;   int len;   unordered_map<int, CacheNode*> cache;      void deleteNodeLink(CacheNode* node) {       CacheNode* prev = nullptr;       CacheNode* next = nullptr;       if (node -> prev) prev = node->prev;       if (prev) {           prev -> next = node -> next;       }       if(node->next) next = node -> next;       if(next) {           next -> prev = prev;       }   }      void insertToHead(CacheNode* node) {       deleteNodeLink(node);       node->prev = head;       node->next = head->next;       if (head -> next) head->next->prev = node;       head->next = node;       cache[node->key] = node;   }};