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