Updated solutions

Author: RodneyShag

Chp. 01 - Arrays and Strings/_1_1_Is_Unique/IsUnique.java

@@ -30,6 +30,5 @@ public static boolean uniqueCharacters(String str) {
 // Follow-up Question: What if we're not allowed to use additional data structures?
 //
 // Answer: Can do brute-force solution by comparing all pairs
-// Time Complexity: O(n^2), but since strings above NUM_ASCII_CHARS=256 immediately
-//                  return false, time complexity becomes O(1)
+// Time Complexity: O(1) since String is max 256 characters. Without this bound it would be O(n^2)
 // Space Complexity: O(1)

Chp. 01 - Arrays and Strings/_1_3_URLify/URLify.java

@@ -26,3 +26,6 @@ public static void replaceWhitespace(char[] sentence, int trueLength) {
         }
     }
 }
+
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 01 - Arrays and Strings/_1_4_Palindrome_Permutation/PalindromePermutation.java

@@ -1,14 +1,14 @@
 package _1_4_Palindrome_Permutation;
 
-import java.util.HashMap;
+import java.util.*;
 
 public class PalindromePermutation {
 
     private static final int NUM_LOWERCASE_LETTERS = 26;
 
     public static boolean palPerm(String str) {
         str = str.toLowerCase().replaceAll("\\s", "");
-        HashMap<Character, Integer> map = new HashMap<>(NUM_LOWERCASE_LETTERS);
+        Map<Character, Integer> map = new HashMap<>(NUM_LOWERCASE_LETTERS);
         for (int i = 0; i < str.length(); i++) {
             Character ch = str.charAt(i);
             if (Character.isLetter(ch)) {

Chp. 01 - Arrays and Strings/_1_5_One_Away/OneAway.java

@@ -53,5 +53,5 @@ private static Boolean oneEditInsert(String s1, String s2) {
     }
 }
 
-//  Time Complexity: O(n+m)
+//  Time Complexity: O(n + m)
 // Space Complexity: O(1)

Chp. 01 - Arrays and Strings/_1_9_String_Rotation/StringRotation.java

@@ -11,3 +11,7 @@ public static boolean isRotation(String s1, String s2) {
 }
 
 // Time/Space Complexities are same as .contains() function
+// If .contains() is implemented using the "KMP algorithm" then we will have:
+//
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 02 - Linked Lists/_2_1_Remove_Dups/RemoveDups.java

@@ -1,11 +1,11 @@
 package _2_1_Remove_Dups;
 
-import java.util.HashSet;
+import java.util.*;
 import common.Node;
 
 public class RemoveDups {
     static void removeDuplicates(Node head) {
-        HashSet<Integer> set = new HashSet<>();
+        Set<Integer> set = new HashSet<>();
         set.add(head.data);
         Node n = head;
         while (n.next != null) {

Chp. 02 - Linked Lists/_2_4_Partition/Partition.java

@@ -10,13 +10,13 @@
 // 2) Create 2 SLLs from SLL. Connect them.        O(n)      Use if swapping data not allowed
 
 public class Partition {
-    /* Solution 1 */
+    // Solution 1
     public static Node partition(Node head, int x) {
         Node curr = head;
         Node p = head;
         while (curr != null) {
             if (curr.data < x) {
-                /* Swap DATA values */
+                // Swap DATA values
                 int temp = p.data;
                 p.data = curr.data;
                 curr.data = temp;
@@ -28,7 +28,7 @@ public static Node partition(Node head, int x) {
         return head;
     }
 
-    /* Solution 2 */
+    // Solution 2
     public static Node partition2(Node n, int x) {
         Node head1 = null;
         Node head2 = null;

Chp. 03 - Stacks and Queues/_3_1_Three_in_One/ThreeInOne.java

@@ -1,6 +1,6 @@
 package _3_1_Three_in_One;
 
-// Use "int[] heads = {-1,-1,-1}" and simply implement arrayOffset(int stackNum) , push/pop/peek
+// Use "int[] heads = {-1,-1,-1}" and simply implement arrayOffset(int stackNum), push/pop/peek
 
 public class ThreeInOne {
     private final int numStacks = 3;
@@ -22,7 +22,7 @@ public void push(int value, int stackNum) throws Exception {
 
     public int pop(int stackNum) throws Exception {
         if (heads[stackNum] == -1) {
-            throw new Exception("No elements to pop");
+            throw new Exception("No element to pop");
         }
         int offset = arrayOffset(stackNum) + heads[stackNum];
         heads[stackNum]--;
@@ -31,7 +31,7 @@ public int pop(int stackNum) throws Exception {
 
     public int peek(int stackNum) throws Exception {
         if (heads[stackNum] == -1) {
-            throw new Exception("No elements to pop");
+            throw new Exception("No element to pop");
         }
         int offset = arrayOffset(stackNum) + heads[stackNum];
         return array[offset];
@@ -45,7 +45,7 @@ private int arrayOffset(int stackNum) {
         return stackSize * stackNum;
     }
 
-    /* Added for testing */
+    // Added for testing
     public void print() {
         for (int stackNum = 0; stackNum <= 2; stackNum++) {
             System.out.print("\nStack #" + stackNum + ": ");
@@ -60,3 +60,6 @@ public void print() {
     // 2) The array is allowed to wrap around on itself (so will need to use % operator)
     // 3) They made a new class called "StackData" to keep track of a bunch of information about each stack instead of just "head"
 }
+
+//  Time Complexity: O(1) for push(), pop(), peek(), isEmpty(), arrayOffset()
+// Space Complexity: O(1) for push(), pop(), peek(), isEmpty(), arrayOffset(). O(n) permanent storage needed for "array"

Chp. 03 - Stacks and Queues/_3_4_Queue_via_Stacks/QueueViaStacks.java

@@ -50,8 +50,6 @@ private void shiftStacks() {
     }
 }
 
-// Time/Space Complexity
-//
 //  Time Complexity: O(1) _amortized_ time for `push()`, `pop()`, `peek()`, `empty()`,
 //                   as each element is only moved from `stack1` to `stack2` at most once.
 // Space Complexity: O(1) for each element being put into our queue.

Chp. 03 - Stacks and Queues/__Intro_Queue/Queue.java

@@ -34,3 +34,6 @@ public Node peek() {
         return head;
     }
 }
+
+//  Time Complexity: O(1) for add(), remove(), peek().
+// Space Complexity: O(1) for add(), remove(), peek(). O(1) to store each Node permanently.

Chp. 03 - Stacks and Queues/__Intro_Stack/Stack.java

@@ -25,3 +25,6 @@ public Node peek() {
         return top;
     }
 }
+
+//  Time Complexity: O(1) for push(), pop(), peek().
+// Space Complexity: O(1) for push(), pop(), peek(). O(1) to store each Node permanently.

Chp. 04 - Trees and Graphs/_4_01_Route_Between_Nodes/RouteBetweenNodes.java

@@ -1,6 +1,6 @@
 package _4_01_Route_Between_Nodes;
 
-import java.util.ArrayDeque;
+import java.util.*;
 import common.GraphNode;
 
 // Algorithm: run BFS from start node and see if we arrive at end node
@@ -11,7 +11,7 @@ public static boolean routeExists(GraphNode start, GraphNode end) {
             return true;
         }
 
-        ArrayDeque<GraphNode> deque = new ArrayDeque<>(); // use deque as a queue
+        Deque<GraphNode> deque = new ArrayDeque<>(); // use deque as a queue
         start.visit();
         deque.add(start);
 

Chp. 04 - Trees and Graphs/_4_05_Validate_BST/ValidateBST.java

@@ -19,4 +19,4 @@ private static boolean isBST(TreeNode node, int min, int max) {
 }
 
 //  Time Complexity: O(n) since we visit every node
-// Space Complexity: O(n) if unbalanced tree, O(log n) if it's balanced. That's the depth of the recursion
+// Space Complexity: O(log n) if tree is balanced, O(n) otherwise, since that's the depth of the recursion

Chp. 04 - Trees and Graphs/_4_06_Successor/Successor.java

@@ -41,4 +41,7 @@ private static TreeNode properParent(TreeNode node) {
 }
 
 // Finding Successor of a Node is useful when deleting a node in a binary *search* tree,
-// since that's a node we can put in place of the deleted node
+// since that's a node we can put in place of the deleted node
+
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 04 - Trees and Graphs/_4_07_Build_Order/BuildOrder.java

@@ -1,12 +1,12 @@
 package _4_07_Build_Order;
 
-import java.util.ArrayDeque;
+import java.util.*;
 
 // From Jeff Erickson's Algorithms.pdf, Section 19.5 Topological Sort
 
 public class BuildOrder {
     // Converts our inconveniently formatted input into a graph
-    public static ArrayDeque<Node> topoSort(String[] projects, String[][] dependencies) throws Exception {
+    public static Deque<Node> topoSort(String[] projects, String[][] dependencies) throws Exception {
         Graph graph = new Graph();
         for (String project : projects) {
             graph.addNode(project);
@@ -19,19 +19,19 @@ public static ArrayDeque<Node> topoSort(String[] projects, String[][] dependenci
         return topoSort(graph);
     }
 
-    private static ArrayDeque<Node> topoSort(Graph graph) throws Exception {
+    private static Deque<Node> topoSort(Graph graph) throws Exception {
         Node source = new Node("Source");
         for (Node node : graph.nodes) {
             source.addDirectedNeighbor(node);
         }
 
-        ArrayDeque<Node> result = new ArrayDeque<>();
+        Deque<Node> result = new ArrayDeque<>();
         topoSortDFS(source, result);
         result.removeFirst(); // removes the source node we created
         return result;
     }
 
-    private static void topoSortDFS(Node n, ArrayDeque<Node> result) throws Exception {
+    private static void topoSortDFS(Node n, Deque<Node> result) throws Exception {
         n.status = Visited.ACTIVE;
         for (Node neighbor : n.neighbors) {
             if (neighbor.status == Visited.NEW) {

Chp. 04 - Trees and Graphs/_4_09_BST_Sequences/BSTSequences.java

@@ -1,58 +1,57 @@
 package _4_09_BST_Sequences;
 
-import java.util.ArrayList;
-import java.util.ArrayDeque;
+import java.util.*;
 import common.TreeNode;
 
 public class BSTSequences {
-    public static ArrayList<ArrayDeque<Integer>> allSequences(TreeNode node) {
-        ArrayList<ArrayDeque<Integer>> results = new ArrayList<>();
+    public static List<Deque<Integer>> allSequences(TreeNode node) {
+        List<Deque<Integer>> results = new ArrayList<>();
 
         if (node == null) {
             results.add(new ArrayDeque<Integer>()); // crucial. So the code labeled "weave lists" works properly
             return results;
         }
 
-        ArrayDeque<Integer> prefix = new ArrayDeque<>();
+        Deque<Integer> prefix = new ArrayDeque<>();
         prefix.add(node.data);
 
-        /* Recursive Cases */
-        ArrayList<ArrayDeque<Integer>> leftSeq  = allSequences(node.left);
-        ArrayList<ArrayDeque<Integer>> rightSeq = allSequences(node.right);
+        // Recursive Cases
+        List<Deque<Integer>> leftSeq  = allSequences(node.left);
+        List<Deque<Integer>> rightSeq = allSequences(node.right);
 
-        /* Weave lists */
-        for (ArrayDeque<Integer> left : leftSeq) {
-            for (ArrayDeque<Integer> right : rightSeq) {
+        // Weave lists
+        for (Deque<Integer> left : leftSeq) {
+            for (Deque<Integer> right : rightSeq) {
                 weaveLists(left, right, results, prefix);
             }
         }
 
         return results;
     }
 
-    private static void weaveLists(ArrayDeque<Integer> list1, ArrayDeque<Integer> list2,
-                      ArrayList<ArrayDeque<Integer>> results, ArrayDeque<Integer> prefix) {
-        /* Base Case */
+    private static void weaveLists(Deque<Integer> list1, Deque<Integer> list2,
+            List<Deque<Integer>> results, Deque<Integer> prefix) {
+        // Base Case
         if (list1.isEmpty() || list2.isEmpty()) {
-            ArrayDeque<Integer> result = new ArrayDeque<>(prefix);
-            result.addAll(list1);
-            result.addAll(list2);
-            results.add(result);
-            return;
+        Deque<Integer> result = new ArrayDeque<>(prefix);
+        result.addAll(list1);
+        result.addAll(list2);
+        results.add(result);
+        return;
         }
-
-        /* Use 1st entry in list1 */
+        
+        // Use 1st entry in list1
         Integer temp = list1.removeFirst();
         prefix.addLast(temp);
         weaveLists(list1, list2, results, prefix);
         prefix.removeLast();
         list1.addFirst(temp);
-
-        /* Use 1st entry in list2 */
+        
+        // Use 1st entry in list2
         temp = list2.removeFirst();
         prefix.addLast(temp);
         weaveLists(list1, list2, results, prefix);
         prefix.removeLast();
         list2.addFirst(temp);
-    }
+       }
 }

Chp. 04 - Trees and Graphs/_4_09_BST_Sequences/Tester.java

@@ -1,7 +1,6 @@
 package _4_09_BST_Sequences;
 
-import java.util.ArrayDeque;
-import java.util.ArrayList;
+import java.util.*;
 
 import common.TreeNode;
 
@@ -11,8 +10,8 @@ public static void main(String[] args) {
         TreeNode root = new TreeNode(2);
         root.left = new TreeNode(1);
         root.right = new TreeNode(3);
-        ArrayList<ArrayDeque<Integer>> results = BSTSequences.allSequences(root);
-        for (ArrayDeque<Integer> result : results) {
+        List<Deque<Integer>> results = BSTSequences.allSequences(root);
+        for (Deque<Integer> result : results) {
             System.out.println(result);
         }
     }

Chp. 04 - Trees and Graphs/_4_10_Check_Subtree/CheckSubtree.java

@@ -3,46 +3,26 @@
 import common.TreeNode;
 
 public class CheckSubtree {
-
     public static boolean containsTree(TreeNode t1, TreeNode t2) {
-        if (t2 == null) { // the empty tree is always a subtree. We do this 
-                          // check here to avoid doing it every time in subTree.
-            return true;
-        }
-        return subTree(t1, t2);
+        StringBuffer sb1 = new StringBuffer();
+        StringBuffer sb2 = new StringBuffer();
+        
+        getPreorder(t1, sb1);
+        getPreorder(t2, sb2);
+        
+        return sb1.indexOf(sb2.toString()) != -1;
     }
 
-    public static boolean subTree(TreeNode t1, TreeNode t2) {
-        if (t1 == null) {
-            return false;
-        }
-
-        if (matchTree(t1, t2)) {
-            return true;
-        }
-
-        return subTree(t1.left, t2) || subTree(t1.right, t2);
-    }
-
-    public static boolean matchTree(TreeNode p, TreeNode q) {
-        if (p == null && q == null) {
-            return true;
-        } else if (p == null || q == null) {
-            return false;
-        }
-        if (p.data != q.data) {
-            return false;
+    private static void getPreorder(TreeNode node, StringBuffer sb) {
+        if (node == null) {
+            sb.append("X");          // Add X representing null
+            return;
         }
-        return matchTree(p.left, q.left) && matchTree(p.right, q.right);
+        sb.append("#" + node.data);  // Add separator and root 
+        getPreorder(node.left, sb);  // Add left
+        getPreorder(node.right, sb); // Add right
     }
 }
 
-// Runtimes: 
-// Let t1 have n nodes and t2 have m nodes
-//
-// Time Complexity: 
-// - O(nm) worst case, but average case is much better since matchTree() usually returns 
-//   false immediately, so it's O(n + km) where k is number of occurrences of T2's root in T1
-// - Also, even when we do call matchTree, it is likely to not match very soon in its search
-//
-// Space Complexity: O(log(n) + log(m)). Which is great.
+//  Time Complexity: O(m + n) if we can assume .indexOf() uses KMP algorithm.
+// Space Complexity: O(m + n)

Chp. 04 - Trees and Graphs/_4_10_Check_Subtree/Tester.java

@@ -11,6 +11,6 @@ public static void main(String[] args) {
         TreeNode tree3 = new TreeNode(5);
         System.out.println("Contains tree? (should be false): " + CheckSubtree.containsTree(tree1, tree2));
         System.out.println("Contains tree? (should be false): " + CheckSubtree.containsTree(tree1, tree3));
-        System.out.println("Contains tree? (should be true): " + CheckSubtree.containsTree(tree1, tree1));
+        System.out.println("Contains tree? (should be true ): " + CheckSubtree.containsTree(tree1, tree1));
     }
 }