[LeetCode] LRU Cache

Question:
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.

解题思路：

LRU是Least Recently Used 的缩写，即“最不常使用”，也就是说，LRU缓存把最不常使用的数据移除，让给最新读取的数据。大多数情况下，最常读取的，也是读取次数最多的，所以，利用LRU缓存我们能够提高系统的performance。 LRU cache是非常频繁出现的一道面试题，一般来讲，当我们问到这道题时，面试官往往想得到的答案是利用 doubly linked list + map(即hashtable) 实现 LRU Cache, 下面我们就利用doubly linked list + map来实现LRU
Cache。

首先，这里使用Doubly linkd list 而不使用 Linked list的原因是：

当访问一个节点后，我们需要将他从原来的list中删除，然后将它插入到头节点处，删除过程中需要将其前后节点连接起来，单链表做不到。
查询：
（1）根据键值查询hashmap，若命中，则返回节点，否则返回null。

（2）从双向链表中删除命中的节点，将其重新插入到表头。

所有操作的复杂度均为O(1)。

插入：

（1）将新的节点关联到map

（2）如果Cache满了，删除双向链表的尾节点，同时删除map对应的记录

（3）将新的节点插入到双向链表中头部
更新：

和查询相似
删除：

从双向链表和map中同时删除对应的记录。

C++代码如下：

struct node
{
node* pre;
int key;
int value;
node* next;
node(int k, int v):key(k),value(v),pre(NULL),next(NULL) {};
};

class LRUCache
{
map<int, node*> mp;
node* head;
node* tail;
int size;
int capacity;
public:
LRUCache(int c)
{
if (c < 1)return;
head = new node(0, 0);
tail = new node(0, 0);
head->next = tail;
tail->pre = head;
mp.clear();
size = 0;
capacity = c;
}

int get(int k)
{
map<int, node*>::iterator it = mp.find(k);
if (it != mp.end())
{
node* cur = (*it).second;
cur->pre->next = cur->next;
cur->next->pre = cur->pre;
putToHead(cur);
return cur->value;
}
else
return -1;
}

void set(int k, int val)
{
if (capacity < 1) return;
map<int, node*>::iterator it = mp.find(k);
if (it != mp.end()) //find
{
node* cur = (*it).second;
cur->pre->next = cur->next;
cur->next->pre = cur->pre;
cur->value = val;
putToHead(cur);
}
else //not find
{
node* tmp = new node(k,val);
putToHead(tmp);
mp[k] = tmp;
if (size < capacity) //size < capacity
{
size++;
}
else //size >= capacity
{
node* deltmp = tail->pre;
tail->pre = deltmp->pre;
deltmp->pre->next = tail;
it = mp.find(deltmp->key);
mp.erase(it);
delete deltmp; //Don't forget the delete operation;
}
}
}

void putToHead(node* cur)
{
cur->next = head->next;
cur->pre = head;
cur->next->pre = cur;
head->next = cur;
}

};