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 public class LRUCache {
 2     private HashMap<Integer,Element> map;
 3     private int capacity;
 4     private int used;
 5     public class Element{
 6         int value, key;
 7         Element next, pre;
 8         public Element(int key, int value){
 9             this.value = value;
10             this.key = key;
11             next = null;
12             pre = null;
13         }
14     }
15     private Element header;
16     public LRUCache(int capacity) {
17         map = new HashMap<Integer,Element>();
18         this.capacity = capacity;
19         used = 0;
20         header = new Element(-1,-1);
21         header.pre = header;
22         header.next = header;
23     }
24     private Element add(Element n){
25     //add to the tail of doublelinkedlist, header is both the header and tail of list
26         header.pre.next = n;
27         n.next = header;
28         n.pre = header.pre;
29         header.pre = n;
30         used ++;
31         return n;
32     }
33     private Element remove(Element n){
34     //remove certain element
35         n.pre.next = n.next;
36         n.next.pre = n.pre;
37         n.pre = null;
38         n.next = null;
39         used --;
40         return n;
41     }
42     public int get(int key) {
43         if(map.containsKey(key)){
44             Element tmp = map.get(key);
45             tmp.pre.next = tmp.next;
46             tmp.next.pre = tmp.pre;
47             remove(tmp);//这个要先remove 才能保证used的值是正确的。
48             Element add = add(tmp);
49             map.put(key, add);
50             return map.get(key).value;  
51         } 
52         return -1;
53     }
54     public void set(int key, int value) {
55         if(key < 1) return;
56         if(map.containsKey(key)){
57             Element tmp = map.get(key);
58             tmp = remove(tmp);
59         }else if(used == capacity){
60             Element lruKey = remove(header.next);
61             map.remove(lruKey.key);
62         }
63         Element add = add(new Element(key, value));
64         map.put(key, add);
65     }
66 }

 第二遍：

 1 public class LRUCache {
 2     public class Element{
 3         int key;
 4         int value;
 5         Element prev, next;
 6         public Element(int key, int value){
 7             this.key = key;
 8             this.value = value;
 9             this.prev = null;
10             this.next = null;
11         }
12     }
13     private int capacity;
14     private int used;
15     private Element header;
16     private HashMap<Integer, Element> map;
17     
18     public LRUCache(int capacity) {
19         this.capacity = capacity;
20         this.used = 0;
21         this.map = new HashMap<Integer, Element>();
22         this.header = new Element(-1, -1);//header for double linked list
23         header.prev = header;
24         header.next = header;
25     }
26     
27     private Element add(Element node){//add to the tail
28         used ++;
29         node.next = header;
30         node.prev = header.prev;
31         header.prev.next = node;
32         header.prev = node;
33         return node;
34     }
35     
36     private Element remove(Element node){//remove node in any position
37         used --;
38         node.prev.next = node.next;
39         node.next.prev = node.prev;
40         node.next = null;
41         node.prev = null;
42         return node;
43     }
44     
45     public int get(int key) {
46         if(map.containsKey(key)){
47             Element tmp = add(remove(map.get(key)));
48             map.put(key, tmp);
49             return tmp.value;
50         }
51         return -1;
52     }
53     
54     public void set(int key, int value) {
55         if(used == capacity || map.containsKey(key)){
56             Element tmp = (map.containsKey(key) ? map.get(key) : header.next);// 这里只能是判断map.containsKey,因为可能出现 map.containsKey 和 used == capaity 同时满足的情况！
57             map.remove(tmp.key);
58             remove(tmp);
59         }
60         Element tmp = add(new Element(key, value));
61         map.put(key, tmp);
62     }
63 }

 

posted on 2013-11-14 08:05  Step-BY-Step  阅读(214)  评论(0)  编辑  收藏  举报

导航