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.

思路1：用哈希

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeMap;

public class LRUCache {
	private static int idx = 0;
    class Node {
		Integer order; 
        Integer v; // v is value
        public Node(int key, int value) {
        	order = key;
        	v = value;
		}
    }
    private TreeMap<Integer, Integer> cacheIndex = new TreeMap<Integer, Integer>();// id -> key
    private HashMap<Integer, Node> cache = new HashMap<Integer, Node>(); // key -> Node
    private int capacity;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
        if(cache.containsKey(key)) {
            return update(key).v;
        }
        return -1;
    }
    
    public void set(int key, int value) {
        if(cache.size() >= capacity && !cache.containsKey(key)) {
            Entry<Integer, Integer> first = cacheIndex.firstEntry();
            cacheIndex.remove(first.getKey());
            cache.remove(first.getValue());
        }
        if(cache.containsKey(key)) {
            Node node = update(key);
            node.v = value;
        } else {
            addNode(key, value);
        }
    }
    
    // create a new node and add to cache
    private void addNode(int key, int value) {
        ++LRUCache.idx;
        Node node = new Node(LRUCache.idx, value);
        cache.put(key, node);
        cacheIndex.put(LRUCache.idx, key);
    }
    
    // return the node by key
    private Node update(int key) {
        ++LRUCache.idx;
        Node node = cache.get(key);
        cacheIndex.remove(node.order);
        node.order = LRUCache.idx;
        cacheIndex.put(LRUCache.idx, key);
        return node;
    }
}

思路2：

用链表，借用这里。

public class LRUCache {

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

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

	private int capacity;
	private HashMap<Integer, Node> map = new HashMap<Integer, Node>();
	private Node head = null;
	private 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;
	}

	private 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;
		}

	}

	private 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);
		}
	}
}