最近最少使用缓存LRUCache

LRU缓存C++简单实现

#include <unordered_map>

/**节点类*/
class DLinkedNode {
	int key, value;
	DLinkedNode* prev;
	DLinkedNode* next;
	DLinkedNode(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {}
	
	friend class LRUCache;
};

class LRUCache {
public:
	LRUCache(int capcity_) :capcity(capcity_), size(0) {
		//为方便操作的伪头部
		head = new DLinkedNode(0, 0);
		//为方便操作的伪尾部
		tail = new DLinkedNode(0, 0);
		head->next = tail;
		tail->prev = head;
		//头尾都不实际加入cache中
	}

	~LRUCache() {
		delete head;
		delete tail;
	}

	int get(int key) {
		if (!cache.count(key)) {
			return -1;//key不存在
		}
		// 如果 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 > capcity) {
				// 如果超出容量，删除双向链表的尾部节点
				DLinkedNode* removed = removeTail();
				// 删除哈希表中对应的项
				cache.erase(removed->key);
				// 删除对象
				delete removed;
				--size;
			}
		}
		else {
			// 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
			DLinkedNode* node = cache[key];
			node->value = value;
			moveToHead(node);
		}
	}

private:
	unordered_map<int, DLinkedNode*> cache;
	DLinkedNode* head;
	DLinkedNode* tail;
	int size, capcity;

	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 = node->next;
		node->next->prev = node->prev;
	}

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

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

来源：oschina

链接：https://my.oschina.net/u/4075062/blog/4897795