refactor 146

fishercoder1534 · fishercoder1534 · commit 42cf89ea5497 · 2017-09-27T07:42:02.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_146.java b/src/main/java/com/fishercoder/solutions/_146.java
@@ -34,132 +34,138 @@ Could you do both operations in O(1) time complexity?
 public class _146 {
 
     public class Solution1 {
-        /**
-         * The shortest implementation is to use LinkedHashMap:
-         * specify a size of the linkedHashMap;
-         * override the removeEldestEntry method when its size exceeds max size:
-         * https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html#removeEldestEntry-java.util.Map.Entry-
-         * in the constructor, set the last boolean variable to be true: it means the ordering mode,
-         * if we set it to be true, it means in access order, false, means it's in insertion order:
-         * https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html#LinkedHashMap-int-float-boolean-
-         */
-
-        private Map<Integer, Integer> cache;
-        private final int max;
-
-        public Solution1(int capacity) {
-            max = capacity;
-            cache = new LinkedHashMap<Integer, Integer>(capacity, 1.0f, true) {
-                public boolean removeEldestEntry(Map.Entry eldest) {
-                    return cache.size() > max;
-                }
-            };
-        }
+        public class LRUCache {
+            /**
+             * The shortest implementation is to use LinkedHashMap:
+             * specify a size of the linkedHashMap;
+             * override the removeEldestEntry method when its size exceeds max size:
+             * https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html#removeEldestEntry-java.util.Map.Entry-
+             * in the constructor, set the last boolean variable to be true: it means the ordering mode,
+             * if we set it to be true, it means in access order, false, means it's in insertion order:
+             * https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html#LinkedHashMap-int-float-boolean-
+             */
+
+            private Map<Integer, Integer> cache;
+            private final int max;
+
+            public LRUCache(int capacity) {
+                max = capacity;
+                cache = new LinkedHashMap<Integer, Integer>(capacity, 1.0f, true) {
+                    public boolean removeEldestEntry(Map.Entry eldest) {
+                        return cache.size() > max;
+                    }
+                };
+            }
 
-        public int get(int key) {
-            return cache.getOrDefault(key, -1);
-        }
+            public int get(int key) {
+                return cache.getOrDefault(key, -1);
+            }
 
-        public void set(int key, int value) {
-            cache.put(key, value);
+            public void set(int key, int value) {
+                cache.put(key, value);
+            }
         }
     }
 
     public class Solution2 {
-        /**The more verbose solution is to write a doubly linked list plus a map.*/
-        private class Node {
-            int key;
-            int value;
-
-            Solution2.Node prev;
-            Solution2.Node next;
+        public class LRUCache {
+            /**
+             * The more verbose solution is to write a doubly linked list plus a map.
+             */
+            private class Node {
+                int key;
+                int value;
+
+                LRUCache.Node prev;
+                LRUCache.Node next;
+
+                Node(int k, int v) {
+                    this.key = k;
+                    this.value = v;
+                }
 
-            Node(int k, int v) {
-                this.key = k;
-                this.value = v;
+                Node() {
+                    this.key = 0;
+                    this.value = 0;
+                }
             }
 
-            Node() {
-                this.key = 0;
-                this.value = 0;
+            private int capacity;
+            private int count;
+            private LRUCache.Node head;
+            private LRUCache.Node tail;
+            private Map<Integer, LRUCache.Node> map;
+            // ATTN: the value should be Node type! This is the whole point of having a class called Node!
+
+            public LRUCache(int capacity) {
+                this.capacity = capacity;
+                this.count = 0;// we need a count to keep track of the number of elements in the cache so
+                // that we know when to evict the LRU one from the cache
+                this.map = new HashMap();
+                head = new LRUCache.Node();
+                tail = new LRUCache.Node();
+                head.next = tail;
+                tail.prev = head;
             }
-        }
-
-        private int capacity;
-        private int count;
-        private Solution2.Node head;
-        private Solution2.Node tail;
-        private Map<Integer, Solution2.Node> map;
-        // ATTN: the value should be Node type! This is the whole point of having a class called Node!
-
-        public Solution2(int capacity) {
-            this.capacity = capacity;
-            this.count = 0;// we need a count to keep track of the number of elements in the cache so
-            // that we know when to evict the LRU one from the cache
-            this.map = new HashMap();
-            head = new Solution2.Node();
-            tail = new Solution2.Node();
-            head.next = tail;
-            tail.prev = head;
-        }
 
-        public int get(int key) {
-            Solution2.Node node = map.get(key);
-            // HashMap allows value to be null, this is superior than HashTable!
-            if (node == null) {
-                return -1;
-            } else {
-
-                /**Do two operations: this makes the process more clear:
-                 * remove the old node first, and then
-                 * just add the node again.
-                 * This will guarantee that this node will be at the latest position:
-                 * the most recently used position.*/
-                remove(node);
-                add(node);
-
-                return node.value;
+            public int get(int key) {
+                LRUCache.Node node = map.get(key);
+                // HashMap allows value to be null, this is superior than HashTable!
+                if (node == null) {
+                    return -1;
+                } else {
+
+                    /**Do two operations: this makes the process more clear:
+                     * remove the old node first, and then
+                     * just add the node again.
+                     * This will guarantee that this node will be at the latest position:
+                     * the most recently used position.*/
+                    remove(node);
+                    add(node);
+
+                    return node.value;
+                }
             }
-        }
 
-        public void set(int key, int value) {
-            Solution2.Node node = map.get(key);
-            if (node == null) {
-                node = new Solution2.Node(key, value);
-                map.put(key, node);
-                add(node);
-                count++;
-
-                if (count > capacity) {
-                    /** ATTN: It's tail.prev, not tail, because tail is always an invalid node, it
-                    doesn't contain anything, it's always the tail.prev that is the last node in the
-                    cache*/
-                    Solution2.Node toDelete = tail.prev;
-                    map.remove(toDelete.key);
-                    remove(toDelete);
-                    count--;
+            public void set(int key, int value) {
+                LRUCache.Node node = map.get(key);
+                if (node == null) {
+                    node = new LRUCache.Node(key, value);
+                    map.put(key, node);
+                    add(node);
+                    count++;
+
+                    if (count > capacity) {
+                        /** ATTN: It's tail.prev, not tail, because tail is always an invalid node, it
+                         doesn't contain anything, it's always the tail.prev that is the last node in the
+                         cache*/
+                        LRUCache.Node toDelete = tail.prev;
+                        map.remove(toDelete.key);
+                        remove(toDelete);
+                        count--;
+                    }
+                } else {
+                    remove(node);
+                    node.value = value;
+                    add(node);
                 }
-            } else {
-                remove(node);
-                node.value = value;
-                add(node);
             }
-        }
 
-        private void remove(Solution2.Node node) {
-            Solution2.Node next = node.next;
-            Solution2.Node prev = node.prev;
-            prev.next = next;
-            next.prev = prev;
-        }
+            private void remove(LRUCache.Node node) {
+                LRUCache.Node next = node.next;
+                LRUCache.Node prev = node.prev;
+                prev.next = next;
+                next.prev = prev;
+            }
 
-        private void add(Solution2.Node node) {
-            // ATTN: we'll always add the node into the first position: head.next!!!!
-            Solution2.Node next = head.next;
-            head.next = node;
-            node.next = next;
-            node.prev = head;
-            next.prev = node;
+            private void add(LRUCache.Node node) {
+                // ATTN: we'll always add the node into the first position: head.next!!!!
+                LRUCache.Node next = head.next;
+                head.next = node;
+                node.next = next;
+                node.prev = head;
+                next.prev = node;
+            }
         }
     }
 }
