LeetCode解题报告:LRU Cache

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.

思路：Java的LinkedHashMap可以实现最近最少使用(LRU)的次序。类似于HashMap。详见《JAVA编程思想(第4版)》P487.

         题目要求是一个固定大小的cache，因此需要一个变量maxCapacity来记录容量大小，用LinkedHashMap存储数据。在添加数据set()方法时，判断一下是否达到maxCapacity，如果cache已经满了，remove掉最长时间不使用的数据，然后put进新的数据。

注意：HashMap,LinkedHashMap,TreeMap的区别，详细看看StackOverFlow

LinkedHashMap最常用的是LRU cache的实现。
如果用C++实现的话， hashmap + 双向链表：用 双向链表记录value 用hashmap记录 key值在链表中的位置（指针）。

unordered_map<int, list<CacheNode>:: iterator> cacheMap;

题解：

import java.util.LinkedHashMap;

public class LRUCache {

	LinkedHashMap<Integer, Integer> linkedmap;
	int maxCapacity;

	public LRUCache(int capacity) {
		this.maxCapacity = capacity;
		this.linkedmap = new LinkedHashMap<Integer, Integer>(capacity, 1f, true);
	}

	public int get(int key) {
		if (linkedmap.containsKey(key))
			return linkedmap.get(key);
		else
			return -1;
	}

	public void set(int key, int value) {
		int size = linkedmap.size();
		if ((size < maxCapacity) || (linkedmap.containsKey(key))) {
			linkedmap.put(key, value);
		} else if (size >= maxCapacity) {
			Iterator<Integer> it = linkedmap.keySet().iterator();//iterator method is superior the toArray(T[] a) method.
			linkedmap.remove(it.next());
			linkedmap.put(key, value);
		}
	}
}

结题遇到的问题：

1.下面这段代码提交的时候超时了。

import java.util.LinkedHashMap;

public class LRUCache {
	LinkedHashMap<Integer, Integer> linkedmap;
	int maxCapacity;

	public LRUCache(int capacity) {
		this.maxCapacity = capacity;
		this.linkedmap = new LinkedHashMap<Integer, Integer>(capacity, 1f, true);
	}

	public int get(int key) {
		if (linkedmap.containsKey(key))
			return linkedmap.get(key);
		else
			return -1;
	}

	public void set(int key, int value) {
		int size = linkedmap.size();
		if ((size < maxCapacity) || (linkedmap.containsKey(key))) {
			linkedmap.put(key, value);
		} else if (size >= maxCapacity) {
			Integer[] keyArray = linkedmap.keySet().toArray(new Integer[0]);//这是超时的代码，采用Iterator不会超时。
			linkedmap.remove(keyArray[0]);
			linkedmap.put(key, value);
		}
	}

}

2.Roger自己实现LinkedHashMap的功能，采用双向链表和哈希表。效率略低于LinkedHashMap.(644ms>548ms)　　

import java.util.HashMap;

public class LRUCache {

	private HashMap<Integer, Entry<Integer>> index;
	private UDFList<Integer> data;

	public LRUCache(int capacity) {
		index = new HashMap<Integer, Entry<Integer>>(capacity);
		data = new UDFList<Integer>(capacity);
	}

	public int get(int key) {
		if (!isExist(key)) {
			index.remove(key);
			return -1;
		}
		if (!index.get(key).equals(data.head)) {
			Entry<Integer> nodePtr = data.adjust(index.get(key));
			index.put(key, nodePtr);
		}
		return index.get(key).element;
	}

	public void set(int key, int value) {
		if (isExist(key)) {
			data.remove(index.get(key));
		}
		index.put(key, data.push(value));
	}

	private boolean isExist(int key) {
		if (index.get(key) == null) {
			return false;
		}
		if (index.get(key).element == null) {
			return false;
		}
		return true;
	}

	public class UDFList<E> {
		public Entry<E> head;
		public Entry<E> tail;
		public final int size;
		public int length = 0;

		public UDFList(int size) {
			head = new Entry<E>(null, null, null);
			tail = head;
			this.size = size;
		}

		public Entry<E> adjust(Entry<E> node) {
			if (node.equals(tail)) {
				tail = tail.previous;
				tail.next = null;
				node.previous = null;
			} else if (node.equals(head)) {
				node = null;
				return head;
			} else {
				node.previous.next = node.next;
				node.next.previous = node.previous;
			}
			head.previous = node;
			node.next = head;
			head = node;
			node = null;
			return head;
		}

		public Entry<E> push(E e) {
			Entry<E> newNode = new Entry<E>(e, null, null);
			if (length == 0) {
				head = newNode;
				tail = head;
			} else {
				head.previous = newNode;
				newNode.next = head;
				head = newNode;
			}
			if (length == size) {
				remove(tail);
			}
			length++;
			return head;
		}

		public void remove(Entry<E> node) {
			if (node == null)
				return;
			node.element = null;
			if (node.equals(head)) {
				head = head.next;
			} else if (node.equals(tail)) {
				tail = tail.previous;
				tail.next = null;
			} else {
				node.previous.next = node.next;
				node.next.previous = node.previous;
			}
			node = null;
			length--;
		}
	}

	public class Entry<E> {
		public E element;
		public Entry<E> previous;
		public Entry<E> next;

		public Entry(E element, Entry<E> next, Entry<E> previous) {
			this.element = element;
			this.next = next;
			this.previous = previous;
		}
	}
}