Updated Chp.2-4 solutions

Author: RodneyShag

Chp. 03 - Stacks and Queues/_3_5_Sort_Stack/SortStack.java

@@ -2,9 +2,6 @@
 
 import java.util.Stack;
 
-//  Time Complexity: O(n^2)
-// Space Complexity: O(n)
-
 public class SortStack {
     public static Stack<Integer> sort(Stack<Integer> stack) {
         Stack<Integer> helperStack = new Stack<>(); // can alternatively use ArrayDeque (it's faster)
@@ -18,3 +15,6 @@ public static Stack<Integer> sort(Stack<Integer> stack) {
         return helperStack;
     }
 }
+
+//  Time Complexity: O(n^2)
+// Space Complexity: O(n)

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

@@ -4,7 +4,6 @@
 import common.GraphNode;
 
 // Algorithm: run BFS from start node and see if we arrive at end node
-// Improvement: Do bi-directional BFS to improve runtime
 
 public class RouteBetweenNodes {
     public static boolean routeExists(GraphNode start, GraphNode end) {
@@ -31,3 +30,5 @@ public static boolean routeExists(GraphNode start, GraphNode end) {
         return false;
     }
 }
+
+// Improvement: Do bi-directional BFS to improve runtime

Chp. 04 - Trees and Graphs/_4_03_List_of_Depths/ListOfDepths.java

@@ -4,21 +4,14 @@
 import java.util.LinkedList;
 import common.TreeNode;
 
-// Tricky Skills:
-// 1) Knowing I should return an "ArrayList<LinkedList<Node>>". 
-// 2) Knowing that, to alter the "ArrayList<LinkedList<Node>>", I should be passing it as a parameter so it can be altered.
-// 3) Know to also pass the "level" down the tree.
-// 4) Remembering to create new LinkedLists in our ArrayList when necessary.
-// 5) Making a DEEP COPY whenever we add Nodes to the list.
-
 public class ListOfDepths {
     public static ArrayList<LinkedList<TreeNode>> createLists(TreeNode root) {
         ArrayList<LinkedList<TreeNode>> lists = new ArrayList<>();
         createListsHelper(root, lists, 0);
         return lists;
     }
 
-    public static void createListsHelper(TreeNode node, ArrayList<LinkedList<TreeNode>> lists, int currLevel) {
+    private static void createListsHelper(TreeNode node, ArrayList<LinkedList<TreeNode>> lists, int currLevel) {
         if (node == null) {
             return;
         }
@@ -37,3 +30,10 @@ public static void createListsHelper(TreeNode node, ArrayList<LinkedList<TreeNod
         createListsHelper(node.right, lists, currLevel + 1);
     }
 }
+
+// Tricky Implementation Details:
+//  1) Knowing to return an "ArrayList<LinkedList<Node>>".
+//  2) Knowing that, to alter the "ArrayList<LinkedList<Node>>", we should pass it as a parameter so it can be altered.
+//  3) Know to also pass the "level" down the tree.
+//  4) Remembering to create new LinkedLists in our ArrayList when necessary.
+//  5) Making a DEEP COPY whenever we add Nodes to the list.

Chp. 04 - Trees and Graphs/_4_04_Check_Balanced/CheckBalanced.java

@@ -4,9 +4,6 @@
 
 // Algorithm: If subtree at Node is imbalanced, return -1. Otherwise, return height of subtree.
 
-//  Time Complexity: O(n)
-// Space Complexity: O(h)
-
 public class CheckBalanced {
     public static boolean isBalanced(TreeNode root) {
         return (isBalancedHelper(root) == -1) ? false : true;
@@ -34,3 +31,6 @@ private static int isBalancedHelper(TreeNode root) {
         return 1 + Math.max(leftHeight, rightHeight);
     }
 }
+
+//  Time Complexity: O(n)
+// Space Complexity: O(n)

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

@@ -2,9 +2,6 @@
 
 import common.TreeNode;
 
-//  Time Complexity: O(n)     - since we visit every node
-// Space Complexity: O(log n) - that's the depth of the recursion
-
 public class ValidateBST {
     public static boolean isBST(TreeNode root) {
         return isBST_Helper(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
@@ -20,3 +17,6 @@ private static boolean isBST_Helper(TreeNode node, int min, int max) {
         return isBST_Helper(node.left, min, node.data) && isBST_Helper(node.right, node.data, max);
     }
 }
+
+//  Time Complexity: O(n)     - since we visit every node
+// Space Complexity: O(log n) - that's the depth of the recursion

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

@@ -2,7 +2,7 @@
 
 import common.TreeNode;
 
-// Read book's logic, but ignore its code. My code is much cleaner.
+// Read book's logic, but ignore its code. The code below is much cleaner.
 // - Notice there are 2 distinct cases: "leftMostChild" (easy to code), "properParent" (a little tricky)
 
 public class Successor {

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

@@ -5,8 +5,7 @@
 class Node {
     public char data;
     public Visited status;
-    public ArrayList<Node> neighbors; // could alternatively use a HashSet (if I
-                                      // give nodes unique IDs)
+    public ArrayList<Node> neighbors; // could alternatively use a HashSet (if I give nodes unique IDs)
 
     /* Constructor */
     public Node(char data) {

Chp. 04 - Trees and Graphs/_4_08_First_Common_Ancestor/FirstCommonAncestor.java

@@ -24,7 +24,7 @@ public static TreeNode commonAnc(TreeNode root, TreeNode p, TreeNode q) {
             return root;
         }
 
-        TreeNode left = commonAnc(root.left, p, q);
+        TreeNode left  = commonAnc(root.left, p, q);
         TreeNode right = commonAnc(root.right, p, q);
 
         if (left == null) {

Chp. 04 - Trees and Graphs/_4_12_Paths_with_Sum/PathWithSums.java

@@ -3,14 +3,9 @@
 import java.util.ArrayList;
 import common.TreeNode;
 
-// Big Trick: Instead of checking if a node starts a path that sums to "value", we check if it ENDS a path
-//            summing to "value".
+// The Big Trick
 //
-// Time/Space complexities: Assuming BALANCED binary tree
-// Time complexity: O(n log(n)) since we touch all "n" nodes, and findSum is O(log n)) in AVERAGE case.
-//                  findSum worst case is O((log n)^2) since it may call print every single time,
-//                  making overall time complexity worst case O(n log(n)^2)
-// Space complexity: O(log n) since that's the max size of a path, and also the max amount of recursive calls on stack.
+// Instead of checking if a node starts a path that sums to "value", we check if it ENDS a path summing to "value".
 
 public class PathWithSums {
     public static void findSum(TreeNode node, int value) {
@@ -47,3 +42,9 @@ private static void printPath(ArrayList<TreeNode> path, int start, int end) {
         }
     }
 }
+
+// Time/Space complexities: Assuming BALANCED binary tree
+// Time complexity: O(n log(n)) since we touch all "n" nodes, and findSum is O(log n)) in AVERAGE case.
+//                  findSum worst case is O((log n)^2) since it may call print every single time,
+//                  making overall time complexity worst case O(n (log n)^2)
+// Space complexity: O(log n) since that's the max size of a path, and also the max amount of recursive calls on stack.

Common/common/GraphFunctions.java

@@ -29,7 +29,7 @@ public static void DFS(GraphNode node, int data) {
     }
 
     // Don't forget:
-    //   1) Use a Queue
+    //   1) Use a Queue (or ArrayDeque as a Queue)
     //   2) .visit() a node before we add it to deque (to avoid duplicates on deque)
     public static void BFS(GraphNode node, int data) {
         if (node == null) {

Common/common/GraphNode.java

@@ -8,7 +8,7 @@
 public class GraphNode {
     public int data;
     public boolean visited; // needed for BFS, DFS
-    private ArrayList<GraphNode> neighbors; // could alternatively use a HashSet (and give nodes unique IDs)
+    private ArrayList<GraphNode> neighbors; // can alternatively use a HashSet (and give nodes unique IDs)
 
     /* Constructor */
     public GraphNode(int data) {

Common/common/TreeNode.java

@@ -1,6 +1,6 @@
 package common;
 
-// Represents a binary Tree. If we wanted an n-ary tree,
+// This represents a binary Tree. If we wanted an n-ary tree,
 // we would use an array of TreeNodes as children
 
 public class TreeNode {