LRUCache算法的简单实现

LRU是Least Recently Used的缩写，意为最近最少使用算法。

LRUCache是一种常用的缓存替换算法，根据使用率淘汰数据，即使用率最小的会被淘汰，通常会用一个双向链表来实现，在这个双向链表中，如果一个cache被命中，则将这个数据移动到链表的头部，而不经常使用的cache就会逐渐移向链表的尾部，我们会给这个链表设置一个大小作为该双向链表的最大容量，当链表达到最大容量时，就取出链表尾部的一个数据丢掉。

缓存里存放的一般是键值对，就是 key / value的结构，最简单的LRUCache大致有两种操作：

一种是get(key)，这个方法是从缓存里查找是否有key的元素，有的话返回其value值， 没有的话返回-1。

一种是set(key, value)，这个方法是，若缓存里没有key的元素，那么放到缓存里，如果缓存已经满了，将最不常用的那个（key, value）给移除，再把新元素放进去，并插入到链表的头部（最前面）；若缓存里已经有key的元素了，那么更新key的value值，并将更新后的key / value放到最前面。

虽然上述中已经用链表实现了基本操作，但是也会存在一个问题：如果直接用双向链表的话，从缓存中取数时每次都需要遍历链表，这样就会消耗大量的时间，如果采用map实现键值key / value对应，这样就避免了每次查找的时候都要在双向链表中顺序遍历了，很大程度上提高了查找的效率。

下面是一个简单的LRUCache的实现：

template
   
   
    
    
class LRUCache {
public:
	LRUCache(int capacity, K ini, T err) {
		head = new ListNode(ini, err_);
		tail = new ListNode(ini, err_);
		head->next = tail;
		tail->prev = head;
		max_size = capacity;
		current_size = 0;
		err_ = err;
	}

	T get(K key) {
		//auto iter = cacheMap.find(key);
		unordered_map
    
    
     
     ::iterator iter;
		iter = cacheMap.find(key);
		if (iter == cacheMap.end()) {
			return err_;
		}
		else {
			ListNode* tmp = iter->second;
			CacheDeleteNode(tmp);
			CacheInsertHead(tmp);
			return tmp->value;
		}
	}

	void set(K key, T value) {
		unordered_map
     
     
      
      ::iterator iter;
		iter = cacheMap.find(key);
		if (iter == cacheMap.end()) {
			if (current_size >= max_size) {
				ListNode* node_ = tail->prev;
				cacheMap.erase(node_->key);
				CacheDeleteNode(node_);
				delete node_;
				ListNode* tmp = new ListNode(key, value);
				CacheInsertHead(tmp);
				cacheMap[key] = tmp;
			}
			else {
				ListNode* tmp = new ListNode(key, value);
				CacheInsertHead(tmp);
				current_size++;
				cacheMap[key] = tmp;
			}
		}
		else {
			ListNode* tmp = iter->second;
			tmp->value = value;
			CacheDeleteNode(tmp);
			CacheInsertHead(tmp);
		}
	}

private:
	struct ListNode {
		K key;
		T value;
		ListNode* prev;
		ListNode* next;
		ListNode(K k_, T v_) :key(k_), value(v_), prev(NULL), next(NULL) {	}
	};

	void CacheInsertHead(ListNode* node) {
		node->next = head->next;
		node->prev = head;
		head->next->prev = node;
		head->next = node;
	}

	void CacheDeleteNode(ListNode* node) {
		node->prev->next = node->next;
		node->next->prev = node->prev;
		//delete node;
	}

private:
	int max_size;
	int current_size;
	unordered_map
      
      
       
        cacheMap;
	ListNode* head;
	ListNode* tail;
	T err_;
};