LRU算法

LRU算法：最近最少使用算法。大意就是根据最近访问的记录，对缓存的数据进行淘汰。如果一个数据最近被访问，或经常访问。则把数据放到列表的前面，而数据很久未访问，或者访问率较低，就会被放在后面，在列表内存不足的时候，将其移除缓存列表。

#include <iostream>
#include <unordered_map>
#include <algorithm>
using namespace std;

//双向链表结构
struct DLinkedNode {
	//保存一个key，value对
	int key, value;
	DLinkedNode* prev;
	DLinkedNode* next;

	DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {}
	DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {}
};

class LRUCache {
private:
	//哈希结构，保存键值映射
	unordered_map<int, DLinkedNode*> cache;
	//双向链表头尾结点
	DLinkedNode* head;
	DLinkedNode* tail;
	//存在多少结点
	int size;
	//容量，总共可以保存多少结点
	int capacity;

public:
	LRUCache(int _capacity): capacity(_capacity), size(0) {
		head = new DLinkedNode();
		tail = new DLinkedNode();
		head->next = tail;
		tail->prev = head;
	}

	int get(int key) {
		//cache.count(key) 返回key元素的个数，若没有返回0
		//find() 返回查找元素的位置(迭代器)，没有返回 cache.end()
		if (!cache.count(key)) {
			return -1;
		}
		//如果key存在,先通过哈希表定位，再将它移动到头部
		DLinkedNode* node = cache[key];
		moveToHead(node);
		return node->value;
	}

	void put(int key, int value) {
		if (!cache.count(key)) {
			//如果key不存在，创建一个新的结点
			DLinkedNode* node = new DLinkedNode(key, value);
			//添加到哈希表
			cache[key] = node;
			//添加到链表头部
			addToHead(node);
			++size;
			if (size > capacity) {
				//如果超过容量，删除链表尾部的结点
				DLinkedNode* removed = removeTail();
				//删除哈希表中对应的项
				cache.erase(removed->key);
				delete removed;
				--size;
			}
			
		}
		else {
			//如果key存在，先通过哈希表定位，再修改value，并移到头部。
			DLinkedNode* node = cache[key];
			node->value = value;
			moveToHead(node);
		}
	}

	void addToHead(DLinkedNode* node) {
		node->prev = head;
		node->next = head->next;
		head->next->prev = node;
		head->next = node;
	}

	void removeNode(DLinkedNode* node) {
		node->prev->next = tail;
		node->next->prev = node->prev;
	}

	void moveToHead(DLinkedNode* node) {
		removeNode(node);
		addToHead(node);
	}

	DLinkedNode* removeTail() {
		DLinkedNode* node = tail->prev;
		removeNode(node);
		return node;
	}
};