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.

思路：

本题的一大特色是使用了双向链表。并且含有两个函数，spilt 和 insert 函数，插入就是把一个节点插入头结点之后的操作函数，而分开就是把当前节点从原有链表中分离出来。

需要说明的是：head 和 tail 节点并不算任何节点。

首先是get 函数：

首先用哈希表查找是否存在，不存在直接返回-1。如果存在，则由于访问了当前数据，先是分离当前节点，再将其插入到最前面。最后返回其值。

其次是set 函数：

先是使用get 函数判断是否存在，注意：如果存在，get 函数已经进行分离和插入操作了。
如果不存在，还需要判断是否超过大小。这里使用hash表的大小判断。没有越界，直接赋值新节点，越界了，先是分离，再插入新节点。

代码：

class LRUCache{
private:
struct Node{
int key;
int value;
Node *prev,*next;
Node(int k,int v):key(k),value(v),prev(NULL),next(NULL){}
};

unordered_map<int , Node*>mapper;
Node *head,*tail;
int capacity;

void insert(Node *target){
target->next=head->next;
head->next->prev=target;
head->next=target;
target->prev=head;
}

void split(Node *target){
target->prev->next=target->next;
target->next->prev=target->prev;
//insert(target);
}

public:
LRUCache(int capacity) {
this->capacity=capacity;
head=new Node(0,0);
tail=new Node(0,0);
head->next=tail;//设立开头结尾指针，方便操作
tail->prev=head;
}

int get(int key) {
if(mapper.find(key)==mapper.end()){
return -1;
}
Node *target=mapper[key];

if(target!=head->next){//如果不是第一个，那么根据最小使用原则，使用了一次target，把他挪到
//最前面
split(target);
insert(target);
}

return target->value;
}

void set(int key, int value) {
if(get(key)!=-1){// 数值已经存在
head->next->value=value;//get 这个函数里面已经有分离 插入 这些操作了.
return;

}
//下面判断不存在，但是要考虑是否越界

Node *tmp=NULL;
if(mapper.size()==capacity){
tmp=tail->prev;
split(tmp);
mapper.erase(tmp->key);
tmp->value=value;
tmp->key=key;
}/*
tmp->value=value;
tmp->key=key;*/ // 不能这么写，因为上面定义的tmp是一个单链表指针，这样赋值是双链表指针
tmp=new Node(key,value);
mapper[key]=tmp;
insert(tmp);
}
};