【CODE】实现一个LRU

实现一个LRU

常见的缓存算法：LRU（最近最少使用，如果数据最近被访问过，那么将来被访问的几率也高）、LFU（最近最不经常使用，如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小）、FIFO（先进先出）。
新数据插到链表头部，每当缓存命中（即缓存数据被访问），则将数据移动到链表头部，当链表满的时候，将链表尾部的数据丢弃。

基本操作：
**set(key,value)**如果key在hashmap中存在，先重置对应的value，然后获取对应节点cur，将cur节点从链表删除，并移动到链表头部，如果key在hashmap中不存在，则新建一个节点，并将节点放到链表头部，当cache存满时，将链表最后一个节点删除。
**get(key)**如果key在hashmap中存在，则把对应的节点放到链表头部，并返回对应的value值，如果不存在，返回-1。
LRU实现采用双向链表+Map：如果使用普通的单链表，删除节点的时候需要从表头开始遍历查找，效率为O(n)，采用双向链表可以直接改变节点的前驱指针的指向并删除，O(1)，使用map节点来保存节点的

双链表节点的定义：

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

对于类LRUCache，构造函数需要指定容量大小：

LRUCache(int capacity){
	size=capacity;
	head=NULL;//链表头指针
	tail=NULL;//链表尾指针
}

双向链表的删除操作：

void remove(CacheNode *node){
	if(node->pre!=NULL){
		node->pre->next=node->next;
	}else{
		head=node->next;//如果要删除的节点没有前驱，表明他是head，将head给next
	}
	if(node->next!=NULL){
		node->next->pre=node->pre;
	}else{
		tail=node->pre;
	}
}

将节点插入到头部：

void setHead(CacheNode *node){
	node->next=head;
	node->pre=NULL;
	if(head!=NULL){
		head->pre=node;
	}
	head=node;
	if(tail==NULL){
		tail=head;//原来是空的
	}
}

get(key)，通过判断map是否含有key即可，如果查找到key，则返回对应的value，否则-1：

int get(int key){
	map<int,CacheNode *> ::iterator it=mp.find(key);
	if(it!=mp.end()){//如果找到了，将原来的从队尾移除，加到队首
		CacheNode *node=it->second;
		remove(node);
		setHead(node);
		return node->value;
	}else
		return -1;
}

set(key,value)，分情况判断，如果当前的key值对应的节点已经存在，则将这个节点取出来，并且删除节点所处的原有位置，并在链表头部加入该节点，如果没有，这个时候需要在头部加入新的节点，插入新节点可能导致容量溢出，如果出现溢出的情况，则需要删除链表尾部的节点。

void set(int key,int value){
	map<int,CacheNode*>::iterator it=mp.find(key);
	if(it!=mp.end()){
		CacheNode *node=it->second;
		node->value=value;//更新value
		remove(node);
		setHead(node);
	}else{
		CacheNode *newNode=new CacheNode(key,value);
		if(mp.size()>=size){
			map<int,CacheNode *>::iterator iter=mp.find(tail->key);
			remove(tail);
			mp.erase(iter);//删除尾节点
		}
		setHead(newNode);//将当前新节点设置为头节点
		mp[key]=newNode;
	}
}