LRU的简单实现(c++实现)

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
/*
双向链表的结构体
*/
struct DListNode {
	int key;
	int val;
	struct DListNode* prev;
	struct DListNode* next;
	DListNode(int _key, int _val) :key(_key), val(_val), prev(nullptr), next(nullptr) {}
	DListNode() :key(0), val(0), prev(nullptr), next(nullptr) {}
};

class LRUCache {
private:
	unordered_map<int, DListNode*> cache;
	DListNode* head;
	DListNode* tail;
	int size;		//长度
	int capacity;	//缓存容量

public:
	LRUCache(int _capacity) :capacity(_capacity), size(0) {
		head = new DListNode();
		tail = new DListNode();
		head->next = tail;
		tail->prev = head;
	}
	~LRUCache() {}
	int get_key(int key) {
		if (!cache.count(key)) return -1;
		DListNode* node = cache[key];
		moveToHead(node);
		return node->val;
	}
	void put(int key, int val)
	{
		//如果在哈希表中找不到key值
		if (!cache.count(key)) {
			DListNode* node = new DListNode(key, val);
			cache[key] = node;
			addToHead(node);//添加这个节点到双向链表头
			++size;
			if (size > capacity) {
				//如果发现链表长度大于容量 删除末尾节点
				DListNode* removed = removeTail();
				cache.erase(removed->key);
				delete removed;
				--size;
			}
		}
		else {
			//已经存在缓存中了 就更新val值
			DListNode* node = cache[key];
			node->val = val;
			//把这个节点移动到表头
			moveToHead(node);
		}
	}

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

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

	void moveToHead(DListNode* node) {
		removeNode(node);
		addToHead(node);
	}
	DListNode* removeTail() {
		DListNode* node = tail->prev;
		removeNode(node);
		return node;
	}


};
void test() {
	int capacity;
	cin >> capacity;
	LRUCache cache = LRUCache(capacity); //缓存容量
	char c;
	int key, val;
	while (cin >> c) {
		if (c == 'p') {
			cin >> key >> val;
			cache.put(key, val);
		}
		else if (c == 'g')
		{
			cin >> key;
			cout << cache.get_key(key) << endl;
		}
	}
}
int main() {
	test();
	return 0;
}