updated 6 solutions

Author: RodneyShag

Chp. 04 - Trees and Graphs/_4_02_Minimal_Tree/MinimalTree.java

@@ -4,6 +4,9 @@
 
 public class MinimalTree {
  public static TreeNode createBST(int[] sortedArray) {
+ if (sortedArray == null) {
+ return null;
+ }
  return createBST(sortedArray, 0, sortedArray.length - 1);
  }
 
@@ -18,3 +21,6 @@ private static TreeNode createBST(int[] sortedArray, int startIndex, int endInde
  return root;
  }
 }
+
+// Time Complexity: O(n)
+// Space Complexity: O(n) since we're creating a Binary Search Tree

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

@@ -1,39 +1,31 @@
 package _4_03_List_of_Depths;
 
-import java.util.ArrayList;
-import java.util.LinkedList;
+import java.util.*;
 import common.TreeNode;
 
 public class ListOfDepths {
- public static ArrayList<LinkedList<TreeNode>> createLists(TreeNode root) {
- ArrayList<LinkedList<TreeNode>> lists = new ArrayList<>();
- createListsHelper(root, lists, 0);
- return lists;
- }
-
- private static void createListsHelper(TreeNode node, ArrayList<LinkedList<TreeNode>> lists, int currLevel) {
- if (node == null) {
- return;
+ public static List<List<Integer>> levelOrder(TreeNode root) {
+ List<List<Integer>> lists = new ArrayList<>();
+ if (root == null) {
+ return lists;
  }
-
- /* Tricky. May need a new list for a new level */
- if (lists.size() == currLevel) { // levels are visited in order, so this should work.
- lists.add(new LinkedList<TreeNode>());
+ ArrayDeque<TreeNode> deque = new ArrayDeque<>(); // use deque as a queue
+ deque.add(root);
+ while (!deque.isEmpty()) {
+ int numNodesInLevel = deque.size();
+ List<Integer> level = new ArrayList<>(numNodesInLevel);
+ for (int i = 0; i < numNodesInLevel; i++) {
+ TreeNode n = deque.remove();
+ level.add(n.data);
+ if (n.left != null) {
+ deque.add(n.left);
+ }
+ if (n.right != null) {
+ deque.add(n.right);
+ }
+ }
+ lists.add(level);
  }
-
- /* Add this Node */
- LinkedList<TreeNode> list = lists.get(currLevel); // get the appropriate list to add the node to.
- list.add(new TreeNode(node.data)); // DEEP COPY - don't forget!
-
- /* Recursively add this nodes subtrees */
- createListsHelper(node.left, lists, currLevel + 1);
- createListsHelper(node.right, lists, currLevel + 1);
+ return lists;
  }
 }
-
-// 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_03_List_of_Depths/Tester.java

@@ -1,20 +1,19 @@
 package _4_03_List_of_Depths;
 
-import java.util.ArrayList;
-import java.util.LinkedList;
+import java.util.*;
 import common.TreeNode;
 import common.TreeFunctions;
 
 public class Tester {
  public static void main(String[] args) {
  System.out.println("*** Test 4.3: List of Depths");
  TreeNode tree = TreeFunctions.createBST();
- ArrayList<LinkedList<TreeNode>> lists = ListOfDepths.createLists(tree);
+ List<List<Integer>> lists = ListOfDepths.levelOrder(tree);
  for (int i = 0; i < lists.size(); i++) {
- LinkedList<TreeNode> list = lists.get(i);
+ List<Integer> list = lists.get(i);
  System.out.format("\nLevel %d: ", i);
- for (TreeNode node : list) {
- System.out.print(node);
+ for (Integer num : list) {
+ System.out.print(num);
  }
  }
  }

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

@@ -6,7 +6,7 @@
 
 public class CheckBalanced {
  public static boolean isBalanced(TreeNode root) {
- return (isBalancedHelper(root) == -1) ? false : true;
+ return isBalancedHelper(root) != -1;
  }
 
  /* Returns -1 if unbalanced, otherwise returns height of tree from given node */
@@ -28,9 +28,10 @@ private static int isBalancedHelper(TreeNode root) {
  if (Math.abs(leftHeight - rightHeight) > 1) {
  return -1; // imbalance between the 2 subtrees
  }
+
  return 1 + Math.max(leftHeight, rightHeight);
  }
 }
 
 // Time Complexity: O(n)
-// Space Complexity: O(n)
+// Space Complexity: O(log n) if balanced tree. O(n) otherwise.

Chp. 10 - Sorting and Searching/_10_03_Search_in_Rotated_Array/SearchInRotatedArray.java

@@ -1,54 +1,39 @@
 package _10_03_Search_in_Rotated_Array;
 
 // - Trick: Endpoints of array give us valuable information. We apply a modified binary search to this problem.
-//
-// - Pitfall: We want to break up the cases by comparing midValue to leftValue. DO NOT break it up by comparing midValue to the
-// value we are searching for like in binary search
-// 
-// - Array can only have 1 inflection point, therefore it is either to the left or right of midIndex. That means 1/2 of the array
-// is ordered normally (in increasing order) and the other half has the inflection point.
+// - Although binary search compares the "middle value" to the "target value", we will break up
+// the cases differently. We will compare middle value `A[mid]` to the start value `A[lo]`
+// - Array can only have 1 inflection point, therefore it is either to the left or right of `mid`. 
+// That means 1/2 of the array is ordered normally (in increasing order) and the other half has the inflection point.
 
 public class SearchInRotatedArray {
- public static Integer search(int[] rotatedArray, int x) {
- return search(rotatedArray, x, 0, rotatedArray.length - 1);
- }
-
- private static Integer search(int[] rotatedArray, int x, int start, int end) {
- if (start > end) {
- return null;
- }
- int midIndex = (start + end) / 2;
- int midValue = rotatedArray[midIndex];
-
- int leftValue = rotatedArray[start];
- int rightValue = rotatedArray[end];
-
- if (midValue == x) {
- return midIndex;
- } else if (leftValue < midValue) { // in this case, left CANNOT have inflection point, thus is ordered correctly
- if (leftValue <= x && x < midValue) {
- return search(rotatedArray, x, start, midIndex - 1);
- } else {
- return search(rotatedArray, x, midIndex + 1, end);
- }
- } else if (leftValue > midValue) { // in this case, left MUST have inflection point, and thus is not ordered correctly
- if (midValue < x && x <= rightValue) {
- return search(rotatedArray, x, midIndex + 1, end);
- } else {
- return search(rotatedArray, x, start, midIndex - 1);
+ public static Integer search(int[] A, int target) {
+ int lo = 0;
+ int hi = A.length - 1;
+ while (lo <= hi) {
+ int mid = (lo + hi) / 2;
+ if (A[mid] == target) {
+ return mid;
  }
- } else { // leftValue == midValue
- if (midValue == rightValue) { // leftValue == midValue == rightValue, so we must search both halves of array since either half could have inflection point
- Integer result = search(rotatedArray, x, start, midIndex - 1);
- if (result == null) {
- result = search(rotatedArray, x, midIndex + 1, end);
+ if (A[lo] < A[mid]) { // in this case, left side CANNOT have inflection point, and is increasing.
+ if (A[lo] <= target && target < A[mid]) {
+ hi = mid - 1;
+ } else {
+ lo = mid + 1;
+ }
+ } else if (A[lo] > A[mid]) {
+ if (A[mid] < target && target <= A[hi]) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
  }
- return result;
- } else { // in this case, inflection point is on right side of array
- return search(rotatedArray, x, midIndex + 1, end);
+ } else { // This iteration of while loop did not divide problem in half.
+ lo++; // Removes just 1 invalid match.
  }
  }
+ return null;
  }
 }
 
-// Time Complexity: O(log n) average case, but O(n) worst case if there are many duplicates.
+// Time Complexity: O(n) due to possible duplicates in array
+// Space Complexity: O(1)

Chp. 17 - More Problems (Hard)/_17_10_Majority_Element/MajorityElement.java

@@ -2,26 +2,35 @@
 
 import java.util.Arrays;
 
+// Let's assume (for now), that the array has a valid majority element
+//
+// Loop through the array. At each index `i`, we treat the array as 2 pieces:
+// - prefix as `[0, i)`
+// - suffix as `[i, end]`
+// Main idea: If we don't have a majority element in the prefix, then the suffix must have a majority element,
+// and this majority element will also be the majority element for the entire array.
+
 public class MajorityElement {
  public static Integer majorityElement(int[] array) {
+ if (array == null) {
+ return null;
+	}
  Integer majority = getCandidate(array);
  return isMajorityValid(array, majority) ? majority : null;
  }
 
  private static Integer getCandidate(int[] array) {
- int majority = 0;
  int count = 0;
- for (int n : array) {
- if (count == 0) {
- majority = n;
- }
- if (majority == n) {
- count++;
- } else {
- count--;
+ Integer candidate = null;
+
+ for (int num : array) {
+ if (count == 0) { // no majority element in prefix
+ candidate = num; // selects new candidate majority element
  }
+ count += (num == candidate) ? 1 : -1;
  }
- return majority;
+
+ return candidate;
  }
 
  private static boolean isMajorityValid(int[] array, int majority) {