Updated LRU solution

Author: RodneyShag

Chp. 16 - More Problems (Moderate)/_16_25_LRU_Cache/DoublyLinkedList.java

@@ -0,0 +1,54 @@
+package _16_25_LRU_Cache;
+
+public class DoublyLinkedList {
+    Node head = null;
+    Node tail = null;
+
+    void addFirst(Node n) {
+        if (head == null) {
+            head = n;
+            tail = n;
+        } else {
+            n.next = head;
+            head.prev = n;
+            head = n;
+        }
+    }
+    
+    void removeLast() {
+    	removeNode(tail);
+//        if (tail == null) {
+//            return null;
+//        } 
+//        if (head == tail) { // only 1 Node in List
+//            Node n = tail;
+//            head = null;
+//            tail = null;
+//            return n;
+//        } else {
+//            Node n = tail;
+//            tail = n.prev;
+//            tail.next = null;
+//            n.prev = null;
+//            return n;
+//        }
+    }
+    
+    void removeNode(Node n) {
+    	if (n == null) {
+    		return;
+    	}
+    	if (n.prev != null) {
+    		n.prev.next = n.next;
+    	}
+    	if (n.next != null) {
+    		n.next.prev = n.prev;
+    	}
+    	if (n == head) {
+    		head = n.next;
+    	}
+    	if (n == tail) {
+    		tail = n.prev;
+    	}
+    }
+}

Chp. 16 - More Problems (Moderate)/_16_25_LRU_Cache/LRUCache.java

@@ -1,37 +1,57 @@
 package _16_25_LRU_Cache;
 
-import java.util.LinkedList;
+import java.util.Map;
 import java.util.HashMap;
 
-// I have to redo this problem to decrease runtime from O(n) to O(1) (like I did in an interview - code is saved)
+// - Excellent explanation in Cracking the Coding Interview, 6th Edition solutions
 
-// To read: http://www.geeksforgeeks.org/implement-lru-cache/
+// FAQ
+//
+// Question: Why have our Node contain both key and value?
+// Answer: Because when we remove from end of Linked List, the Node's key is used
+//         to find the Node in the HashMap (to remove the node there as well)
 
 class LRUCache {
-    private final int maxSize = 7;
-    private LinkedList<Item> items = new LinkedList<>();
-    private HashMap<String, Item> map = new HashMap<>();
-
-    void add(Item item) {
-        if (items.size() == maxSize) {
-            map.remove(items.peekLast());
-            items.removeLast();
+    private int maxSize;
+    private Map<Integer, Node> map; // gives us constant access to Nodes
+    private DoublyLinkedList dll;   // used to keep track of "freshness" of Nodes
+    
+    public LRUCache(int maxSize) {
+        this.maxSize = maxSize;
+        map = new HashMap<>();
+        dll = new DoublyLinkedList();
+    }
+
+    public void add(Integer key, Node value) {
+        if (map.containsKey(key)) {
+            get(key);
+        } else {
+            if (map.size() == maxSize) {
+            	Node n = dll.tail;
+                dll.removeLast();
+                map.remove(n.key);
+            }
+            map.put(key, value);
+            dll.addFirst(value);
         }
-        items.addFirst(item);
-        map.put(item.name, item);
     }
 
-    public Item access(String str) {
-        Item item = map.get(str);
-        if (item == null) {
-            return null;
+    public Node get(Integer key) {
+    	Node n = map.get(key);
+
+    	// Update Freshness
+    	if (n.prev != null) {
+            n.prev.next = n.next;
         }
-        items.remove(item); // this may be O(n) instead of the O(1) that we wanted.
-        items.addFirst(item);
-        return item;
+        if (n.next != null) {
+            n.next.prev = n.prev;
+        }
+        dll.addFirst(n);
+
+        return n;
     }
 
-    public LinkedList<Item> getItems() {
-        return items;
+    public DoublyLinkedList getItems() {
+        return dll;
     }
 }

Chp. 16 - More Problems (Moderate)/_16_25_LRU_Cache/Node.java

@@ -0,0 +1,20 @@
+package _16_25_LRU_Cache;
+
+public class Node {
+	int key;
+    String value;
+    Node next;
+    Node prev;
+
+    public Node(int k, String v) {
+    	key = k;
+        value = v;
+        next = null;
+        prev = null;
+    }
+    
+    @Override
+    public String toString() {
+        return value;
+    }
+}

Chp. 16 - More Problems (Moderate)/_16_25_LRU_Cache/Tester.java

@@ -5,16 +5,20 @@ public static void main(String[] args) {
         System.out.println("*** Test 16.25: LRU Cache\n");
 
         /* Create LRU Cache */
-        LRUCache cache = new LRUCache();
+        LRUCache cache = new LRUCache(7);
         for (int i = 20; i >= 1; i--) {
-            Item item = new Item("Item " + i);
-            cache.add(item);
+            Node node = new Node(i, "Node " + i + " value");
+            cache.add(i, node);
         }
 
         /* Access Item 4, and print cache items */
-        cache.access("Item 4"); // should move it to head of cache
-        for (Item item : cache.getItems()) {
-            System.out.println(item);
+        cache.get(4); // should move it to head of cache
+        DoublyLinkedList items = cache.getItems();
+        Node head = items.head;
+        Node n = head;
+        while (n != null) {
+        	System.out.println(n);
+        	n = n.next;
         }
     }
 }