146. LRU Cache

https://leetcode.com/problems/lru-cache/discuss/45922/JAVA-Easy-Version-To-Understand!!!!

 

 

 1 //O(1)
 2 
 3 class LRUCache {
 4     class Node{
 5         int key;
 6         int value;
 7         Node next;
 8         Node prev;
 9         Node(int x, int y){
10             key = x;
11             value = y;
12         }
13         
14     }
15     Node head;
16     Node tail;
17     
18     public void delete(Node node){
19         node.prev.next = node.next;
20         node.next.prev = node.prev;
21     }
22     
23     public void addToHead(Node node){
24         node.prev = head;
25         node.next = head.next;
26         head.next = node;
27         node.next.prev = node;
28     }
29     
30     HashMap<Integer, Node> map = new HashMap<>();
31     int capa;
32     int count;
33 
34     public LRUCache(int capacity) {
35         capa = capacity;
36         count = 0;
37         head = new Node(0, 0);
38         tail = new Node(0, 0);
39         head.prev = null;
40         head.next = tail;
41         tail.prev = head;
42         tail.next = null;
43         
44     }
45     
46     public int get(int key) {
47         if(map.containsKey(key)){
48             Node node = map.get(key);
49             delete(node);
50             addToHead(node);
51             return node.value;
52         }else{
53             return -1;
54         }
55         
56     }
57     
58     public void put(int key, int value) {
59         if(map.containsKey(key)){
60             Node node = map.get(key);
61             node.value = value;
62             delete(node);
63             addToHead(node);
64         }else{
65             if(count < capa){
66                 Node node = new Node(key, value);
67                 map.put(key, node);
68                 addToHead(node);
69                 count++;
70             }else{
71                 map.remove(tail.prev.key);
72                 delete(tail.prev);
73                 Node node = new Node(key, value);
74                 addToHead(node);
75                 map.put(key, node);
76                 
77             }
78         }
79         
80     }
81 }

 

 1 // O(n) List记录先后， map存key value
 2 class LRUCache {
 3     List<Integer> order;
 4     HashMap<Integer, Integer> map;
 5     int max = 0;
 6 
 7     public LRUCache(int capacity) {
 8         order = new ArrayList<>();
 9         max  = capacity;
10         map = new HashMap<>();
11         
12         
13     }
14     
15     public int get(int key) {
16         if(map.containsKey(key)){
17             order.remove(new Integer(key));
18             order.add(key);
19             return map.get(key);
20         }else{
21             return -1;
22         }
23         
24     }
25     
26     public void put(int key, int value) {
27         if(get(key) != -1){
28             map.put(key, value);
29             return;
30         }
31         if(order.size() >= max){
32             int k = order.get(0);
33             order.remove(0);
34             map.remove(new Integer(k));
35         }
36         map.put(key, value);
37         order.add(key);
38         
39     }
40 }

 

posted @ 2018-10-26 05:40  jasoncool1  阅读(161)  评论(0)  编辑  收藏  举报