[LeetCode] LRU Cache

题目：

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.

set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

分析：

解决这个问题的关键点在于构造一个双向链表，可以做到快速移动节点。

LRU Cache可以利用双向链表和HashMap进行实现。HashMap使得get(key)操作的时间复杂度为O(1)。双向链表使得移动和删除操作的时间复杂度为O(1)。

代码：

import java.util.HashMap;

class Node {
	int key;
	int value;
	Node pre;
	Node next;

	public Node(int key, int value) {
		this.key = key;
		this.value = value;
	}
}

public class LRUCache {
	int capacity;
	HashMap<Integer, Node> map = new HashMap<Integer, Node>();
	Node head = null;
	Node end = null;

	public LRUCache(int capacity) {
		this.capacity = capacity;
	}

	public int get(int key) {
		if(map.containsKey(key)) {
			Node n = map.get(key);
			remove(n);
			setHead(n);
			return n.value;
		}
		return -1;
	}

	public void remove(Node n) {
		if(n.pre != null) {
			n.pre.next = n.next;
		} else {
			head = n.next;
		}

		if(n.next != null) {
			n.next.pre = n.pre;
		} else {
			end = n.pre;
		}
	}

	public void setHead(Node n) {
		n.next = head;
		n.pre = null;

		if(head != null)
			head.pre = n;

		head = n;

		if(end == null)
			end = head;
	}

	public void set(int key, int value) {
		if(map.containsKey(key)) {
			Node old = map.get(key);
			old.value = value;
			remove(old);
			setHead(old);
		} else {
			Node created = new Node(key, value);
			if(map.size() >= capacity) {
				map.remove(end.key);
				remove(end);
				setHead(created);
			} else {
				setHead(created);
			}

			map.put(key, created);
		}
	}
}