C++手撸哈希双链表：LRU缓存

struct Node {
	int key;
	int val;
	Node* prev;
	Node* next;
	Node(int key, int val) {
		this->key = key;
		this->val = val;
	}
};

//以Node为节点构造双链表
struct DoubleList {
	Node *head, *tail;
	int size;
	DoubleList() {
		head = new Node(0, 0);
		tail = new Node(0, 0);
		head->next = tail;
		tail->prev = head;
		this->size = 0;
	}

	//在尾部添加节点
	void addList(Node* x) {
		x->next = tail;
		x->prev = tail->prev;
		tail->prev->next = x;
		tail->prev = x;
		this->size++;
	}

	//删除节点
	void remove(Node* x) {
		x->prev->next = x->next;
		x->next->prev = x->prev;
		this->size--;
	}

	//删除双链表中的第一个节点，并返回该节点
	Node* removeFirst() {
		if (head->next == tail) {
			return NULL;
		}
		Node* first = head->next;
		remove(first);
		return first;
	}

	int size1() {
		return this->size;
	}
};

class LRUCache {
public:
	unordered_map<int, Node*> map;
	DoubleList cache;
	int cap;
	LRUCache(int cap) {
		this->cap = cap;
	}

	//将某个Key提为最近使用的
	void makeRecently(int key) {
		Node* x = map[key];
		cache.remove(x);
		cache.addList(x);
	}

	//添加最近使用的
	void addRecently(int key, int val) {
		Node* x = new Node(key, val);
		cache.addList(x);
		map[key] = x;
	}

	//删除某一个key
	void deleteKey(int key) {
		Node* x = map[key];
		cache.remove(x);
		map.erase(key);
	}

	//删除最久未使用的元素
	void deleteLeastRecently() {
		Node* deletedNode = cache.removeFirst();
		int deleteKey = deletedNode->key;
		map.erase(deleteKey);
	}

	int get(int key) {
		if (!map.count(key)) {
			return -1;
		}
		makeRecently(key);
		return map[key]->val;
	}

	void put(int key, int val) {
		if (map.count(key)) {
			map[key]->val = val;
            makeRecently(key);
		}
		else {
			if (cache.size1() >= this->cap) {
				deleteLeastRecently();
			}
            addRecently(key, val);
		}
	}
};