Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get
and put
.
get(key)
- Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.put(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.
The cache is initialized with a positive capacity.
Follow up:
Could you do both operations in O(1) time complexity?
Example:
LRUCache cache = new LRUCache( 2 /* capacity */ ); cache.put(1, 1); cache.put(2, 2); cache.get(1); // returns 1 cache.put(3, 3); // evicts key 2 cache.get(2); // returns -1 (not found) cache.put(4, 4); // evicts key 1 cache.get(1); // returns -1 (not found) cache.get(3); // returns 3 cache.get(4); // returns 4
class LRUCache { private Map<Integer, Integer> map; private int capacity; public LRUCache(int capacity) { this.capacity = capacity; map = new LinkedHashMap<Integer, Integer>(); } public int get(int key) { Integer val = map.get(key); if (val == null) return -1; map.remove(key); map.put(key, val);//确保get后当前key变成最后一个插入的 return val; } public void put(int key, int value) { map.remove(key);//Why? Because假如update键的新value也算作visited,要先把当前key删掉重新insert确保是最后一个插入的 map.put(key, value); if (map.size() > capacity){ // for(Map.Entry<Integer, Integer> entry: map.entrySet()){ // System.out.println("key"+entry.getKey()+"value"+entry.getValue()); // } map.remove(map.entrySet().iterator().next().getKey()); } } } /** * Your LRUCache object will be instantiated and called as such: * LRUCache obj = new LRUCache(capacity); * int param_1 = obj.get(key); * obj.put(key,value); */
来自小土刀大神,短小精悍,用了LinkedHashMap的特性(保留插入顺序)。
get的时候先取出value,然后重新插入确保这个key是最后一个值。
put的时候也是要先remove了再重新put进去保证update键的情况
class LRUCache { Node head = new Node(0, 0), tail = new Node(0, 0); Map<Integer, Node> map = new HashMap(); int capacity; public LRUCache(int _capacity) { capacity = _capacity; head.next = tail; tail.prev = head; } public int get(int key) { if(map.containsKey(key)) { Node node = map.get(key); remove(node); insert(node); return node.value; } else { return -1; } } public void put(int key, int value) { if(map.containsKey(key)) { remove(map.get(key)); } if(map.size() == capacity) { remove(tail.prev); } insert(new Node(key, value)); } private void remove(Node node) { map.remove(node.key); node.prev.next = node.next; node.next.prev = node.prev; } private void insert(Node node){ map.put(node.key, node); Node headNext = head.next; head.next = node; node.prev = head; headNext.prev = node; node.next = headNext; } class Node{ Node prev, next; int key, value; Node(int _key, int _value) { key = _key; value = _value; } } }
用linkedhashmap太赖了,用一般hashmap估计能报名
原理:Node:prev,next,key,val
然后用一个头节点head,尾节点tail执行insert和remove操作,insert每次加到最前边,也就是head。next。remove每次把tail.prev移除掉,注意更新节点的prev,next