Updated solutions

Author: RodneyShag

Chp. 08 - Recursion and Dynamic Programming/_8_03_Magic_Index/MagicIndex.java

@@ -1,27 +1,26 @@
 package _8_03_Magic_Index;
 
 public class MagicIndex {
-    /* Part 1 - Use standard Binary Search: O(log n) time on sorted array. Only works if no duplicate numbers */
+    // Part 1 - Use standard Binary Search: O(log n) time on sorted array. Only works if no duplicate numbers
     public static Integer magicFast(int[] sortedArray) {
-        return magicFast(sortedArray, 0, sortedArray.length - 1);
-    }
+        int lo = 0;
+        int hi = sortedArray.length - 1;
 
-    private static Integer magicFast(int[] sortedArray, int start, int end) {
-        if (start > end) {
-            return null;
-        }
-        int midIndex = (start + end) / 2;
-        int midValue = sortedArray[midIndex];
-        if (midValue == midIndex) {
-            return midIndex;
-        } else if (midValue > midIndex) {
-            return magicFast(sortedArray, start, midIndex - 1);
-        } else {
-            return magicFast(sortedArray, midIndex + 1, end);
+        while (lo <= hi) {
+            int midIndex = (lo + hi) / 2;
+            int midValue = sortedArray[midIndex];
+            if (midValue == midIndex) {
+                return midIndex;
+            } else if (midValue > midIndex) {
+                hi = midIndex - 1;
+            } else {
+                lo = midIndex + 1;
+            }
         }
+        return null;
     }
 
-    /* Part 2 - If integers in sorted array are NOT UNIQUE. O(n) runtime */
+    // Part 2 - If integers in sorted array are NOT UNIQUE. O(n) runtime, O(n) space complexity.
     public static Integer magicFast2(int[] sortedArray) {
         return magicFast2(sortedArray, 0, sortedArray.length - 1);
     }
@@ -36,15 +35,17 @@ private static Integer magicFast2(int[] sortedArray, int start, int end) {
             return midIndex;
         }
 
-		/* Search Left. If we find the result, return it. */
+		// Search Left. If we find the result, return it.
         int leftIndex = Math.min(midValue, midIndex - 1); // see algorithm in book for explanation if this line is confusing.
         Integer left = magicFast2(sortedArray, start, leftIndex);
         if (left != null) {
             return left;
         }
 
-        /* Search Right (Since we couldn't find it in left) */
+        // Search Right (Since we couldn't find it in left)
         int rightIndex = Math.max(midValue, midIndex + 1);
         return magicFast2(sortedArray, rightIndex, end);
     }
+    
+    // For Part 2, an alternate solution is to just loop through the array in search of the value for O(n) time, O(1) space complexity
 }

Chp. 10 - Sorting and Searching/_10_04_Sorted_Search_No_Size/SortedSearchNoSize.java

@@ -25,5 +25,5 @@ public static int binarySearch(Listy listy, int value, int start, int end) {
     }
 }
 
-// Time Complexity: O(log n)
-
+//  Time Complexity: O(log n)
+// Space Complexity: O(1)

Chp. 10 - Sorting and Searching/_10_10_Rank_from_Stream/RankFromStream.java

@@ -7,15 +7,15 @@
 // Array            O(n) due to shifting              O(log n) using binary search
 // Linked List      O(n)                              O(n) since we can't do binary search on linked list
 // HashMap          O(1)                              O(n) since HashMap doesn't help us find rank in any way (it's not sorted)
-// BST              O(log n)                          O(log n) (assuming it's balanced)
+// BST              O(log n) (if balanced tree)       O(log n) (if balanced tree)
 //
 // Note: Insert for array and linked list are O(n) since we insert into the position necessary to keep the data structure sorted
 
 public class RankFromStream {
 
     private static RankNode root = null;
 
-    /* Called each time a number is generated */
+    // Called each time a number is generated
     public static void track(int x) {
         if (root == null) {
             root = new RankNode(x);
@@ -24,40 +24,45 @@ public static void track(int x) {
         }
     }
 
-    private static void insert(int x, RankNode node) {
-        if (x <= node.data) {
-            node.leftSize++;
-            if (node.left == null) {
-                node.left = new RankNode(x);
+    private static void insert(int x, RankNode root) {
+        RankNode curr = root;
+        while (true) {
+            if (x <= curr.data) {
+                curr.leftSize++;
+                if (curr.left == null) {
+                    curr.left = new RankNode(x);
+                    return;
+                } else {
+                    curr = curr.left;
+                }
             } else {
-                insert(x, node.left);
-            }
-        } else {
-            if (node.right == null) {
-                node.right = new RankNode(x);
-            } else {
-                insert(x, node.right);
+                if (curr.right == null) {
+                    curr.right = new RankNode(x);
+                    return;
+                } else {
+                    curr = curr.right;
+                }
             }
         }
     }
 
-    /* Returns number of values less than or equal to x (not including x itself) */
+    // Returns number of values less than or equal to x (not including x itself)
     public static int getRankOfNumber(int x) {
         if (root == null) {
             return 0;
         }
-        return getRankOfNumber(x, root);
-    }
-
-    private static int getRankOfNumber(int x, RankNode node) {
-        if (node == null) {
-            return 0;
-        } else if (x == node.data) {
-            return node.leftSize;
-        } else if (x > node.data) {
-            return 1 + node.leftSize + getRankOfNumber(x, node.right);
-        } else {
-            return getRankOfNumber(x, node.left);
+        RankNode curr = root;
+        int rank = 0;
+        while (curr != null) {
+            if (x == curr.data) {
+                return rank + curr.leftSize;
+            } else if (x > curr.data) {
+                rank += 1 + curr.leftSize;
+                curr = curr.right;
+            } else {
+                curr = curr.left;
+            }
         }
+        return 0;
     }
 }

Chp. 10 - Sorting and Searching/_10_11_Peaks_and_Valleys/PeaksAndValleys.java

@@ -21,3 +21,6 @@ private static void swap(int[] array, int left, int right) {
         array[right] = temp;
     }
 }
+
+//  Time Complexity: O(n)
+// Space Complexity: O(1)

Chp. 16 - More Problems (Moderate)/_16_04_Tic_Tac_Win/TicTacWin.java

@@ -5,7 +5,7 @@
 //	2) Use an array of booleans to indicate which boards are winning boards.
 
 public class TicTacWin {
-    boolean[] winnerMap;
+    private boolean[] winnerMap;
 
     public static int convertBoardToInt(char[][] board) {
         int sum = 0;

Chp. 16 - More Problems (Moderate)/_16_15_Master_Mind/MasterMind.java

@@ -17,7 +17,7 @@ public static Result estimate(String guess, String solution) {
         Result result = new Result();
         Map<Character, Integer> colorMap = new HashMap<>();
 
-        // Count direct hits, while saving non-directHit colors in a HashMap, which will later help us count pseudohits
+        // Count direct hits. Save other colors in HashMap for later.
         for (int i = 0; i < solution.length(); i++) {
             char solChar = solution.charAt(i);
             char guessChar = guess.charAt(i);

Chp. 16 - More Problems (Moderate)/_16_20_T9__HashMap_Solution/T9.java

@@ -7,9 +7,10 @@
 //      value = List of Valid Words
 
 public class T9 {
-    private static Map<Character, Character> letterToDigit = new HashMap<>();
+    private Map<Character, Character> letterToDigit;
 
-    static { // static initializer block
+    public T9() {
+        letterToDigit = new HashMap<>();
         for (char ch = 'a'; ch <= 'c'; ch++) letterToDigit.put(ch, '2');
         for (char ch = 'd'; ch <= 'f'; ch++) letterToDigit.put(ch, '3');
         for (char ch = 'g'; ch <= 'i'; ch++) letterToDigit.put(ch, '4');
@@ -20,7 +21,7 @@ public class T9 {
         for (char ch = 'w'; ch <= 'z'; ch++) letterToDigit.put(ch, '9');
     }
 
-    public static Map<String, List<String>> buildMap(String[] words) {
+    public Map<String, List<String>> buildMap(String[] words) {
         Map<String, List<String>> map = new HashMap<>();
         for (String word : words) {
             String number = getNumber(word);
@@ -31,7 +32,7 @@ public static Map<String, List<String>> buildMap(String[] words) {
         return map;
     }
 
-    private static String getNumber(String str) {
+    private String getNumber(String str) {
         StringBuffer sb = new StringBuffer();
         for (int i = 0; i < str.length(); i++) {
             char ch = letterToDigit.get(str.charAt(i));

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

@@ -8,7 +8,8 @@ public class Tester {
 
     public static void main(String[] args) {
         System.out.println("*** Test 16.20: T9 - HashMap Solution\n");
-        Map<String, List<String>> map = T9.buildMap(words);
+        T9 t9 = new T9();
+        Map<String, List<String>> map = t9.buildMap(words);
         System.out.println("Matching words: ");
         for (String word : map.get("8733")) {
             System.out.println(word);

Chp. 17 - More Problems (Hard)/_17_03_Random_Set/RandomSet.java

@@ -16,6 +16,9 @@ to decide if array[n] should be inserted into our subset (which would require pu
 */
 public class RandomSet {
     public int[] generate(int[] array, int m) {
+        if (array == null || m > array.length) {
+            return null;
+        }
         /* Copy first "m" elements into new array */
         int[] solution = new int[m];
         for (int i = 0; i < m; i++) {

Chp. 17 - More Problems (Hard)/_17_11_Word_Distance/WordDistance.java

@@ -45,9 +45,7 @@ public static Integer shortest(String[] words, String word1, String word2) {
     public static void preProcess(String[] words) {
         for (int i = 0; i < words.length; i++) {
             String currWord = words[i];
-            if (!map.containsKey(currWord)) {
-                map.put(currWord, new ArrayList<Integer>());
-            }
+            map.putIfAbsent(currWord, new ArrayList<Integer>());
             List<Integer> positions = map.get(currWord);
             positions.add(i);
         }
@@ -87,7 +85,7 @@ private static Integer findDistance(List<Integer> listA, List<Integer> listB) {
 
     private static List<Pair> merge(List<Integer> listA, List<Integer> listB) {
         if (listA == null || listB == null || listA.size() == 0 || listB.size() == 0) {
-            return null; // function assumes both lists are non-empty (to make error-checking easier to write)
+            return new ArrayList<>();
         }
 
         List<Pair> merged = new ArrayList<>();

Chp. 17 - More Problems (Hard)/_17_14_Smallest_K/SmallestK.java

@@ -34,17 +34,17 @@ public static void findNthSmallestNums(int[] array, int n) {
     //  - O(n) average run-time is since we recurse only on 1 side (n + n/2 + n/4 + ...) = n (1 + 1/2 + 1/4 + ...) = O(n).
     //    Our formula above is a geometric series with "r = 1/2", which would converge to 1/(1-r) for infinite geometric series.
     //  - O(n^2) worst-case run-time is if "partition()" consistently picks a bad pivot.
-    private static Integer quickselect(int[] array, int n) {
-        int start = 0;
-        int end   = array.length - 1;
-        while (start <= end) {
-            int pivotIndex = partition(array, start, end);
+    private static Integer quickselect(int[] A, int n) {
+        int lo = 0;
+        int hi = A.length - 1;
+        while (lo <= hi) {
+            int pivotIndex = partition(A, lo, hi);
             if (pivotIndex == n) {
-                return array[n];
+                return A[n];
             } else if (pivotIndex < n) {
-                start = pivotIndex + 1;
+                lo = pivotIndex + 1;
             } else {
-                end = pivotIndex - 1;
+                hi = pivotIndex - 1;
             }
         }
         return null;
@@ -54,31 +54,31 @@ private static Integer quickselect(int[] array, int n) {
     //     1) Left side has values smaller than pivotValue
     //     2) Right side has values larger than pivotValue
     // Returns pivotIndex
-    private static Integer partition(int[] array, int start, int end) {
-        if (start > end) {
+    private static Integer partition(int[] A, int lo, int hi) {
+        if (lo > hi) {
             return null;
         }
-        int pivotIndex = (start + end) / 2; // there are many ways to choose a pivot
-        int pivotValue = array[pivotIndex];
+        int pivotIndex = (lo + hi) / 2; // there are many ways to choose a pivot
+        int pivotValue = A[pivotIndex];
 
-        swap(array, pivotIndex, end); // puts pivot at end for now.
+        swap(A, pivotIndex, hi); // puts pivot at end for now.
 
-        /* Linear search, comparing all elements to pivotValue and swapping as necessary */
-        int indexToReturn = start;	// Notice we set it to "start", not to "0".
-        for (int i = start; i < end; i++) {
-            if (array[i] < pivotValue) {
-                swap(array, i, indexToReturn);
+        // Linear search, comparing all elements to pivotValue and swapping as necessary
+        int indexToReturn = lo; // Notice we set it to "lo", not to "0".
+        for (int i = lo; i < hi; i++) {
+            if (A[i] < pivotValue) {
+                swap(A, i, indexToReturn);
                 indexToReturn++;
             }
         }
 
-        swap(array, indexToReturn, end); // puts pivot where it belongs
+        swap(A, indexToReturn, hi); // puts pivot where it belongs
         return indexToReturn;
     }
 
-    private static void swap(int[] array, int i, int j) {
-        int temp = array[i];
-        array[i] = array[j];
-        array[j] = temp;
+    private static void swap(int[] A, int i, int j) {
+        int temp = A[i];
+        A[i] = A[j];
+        A[j] = temp;
     }
 }

Chp. 17 - More Problems (Hard)/_17_14_Smallest_K/Tester.java

@@ -13,7 +13,7 @@ public static void main(String[] args) {
     }
 
     private static void test(int[] array, int k) {
-        System.out.format("\n%2 d Smallest: ", k);
+        System.out.format("\n%2d Smallest: ", k);
         SmallestK.findNthSmallestNums(array, k);
     }
 }

Chp. 17 - More Problems (Hard)/_17_18_Shortest_Supersequence/HeapNode.java

@@ -2,7 +2,7 @@
 
 public class HeapNode {
     int value; // same as the value that's the key in our HashMap
-    int index;
+    int index; // index in array it came from
 
     HeapNode(int listID, int pos) {
         this.value = listID;

Chp. 17 - More Problems (Hard)/_17_18_Shortest_Supersequence/NodeComparator.java

@@ -15,16 +15,15 @@
 // Time Complexity: O(S + B log S)
 
 public class ShortestSupersequence {
-    public static void shortest(int[] arrayA, int[] arrayB) {
+    public static Range shortest(int[] arrayA, int[] arrayB) {
         Map<Integer, Deque<HeapNode>> map = makeLists(arrayA, arrayB);
-        Range range = getSmallestRange(map);
-        System.out.println("Range: " + range);
+        return getSmallestRange(map);
     }
 
     private static Map<Integer, Deque<HeapNode>> makeLists(int[] arrayA, int[] arrayB) {
         Map<Integer, Deque<HeapNode>> map = new HashMap<>();
         for (int num : arrayA) {
-            map.put(num, new ArrayDeque<>());
+            map.putIfAbsent(num, new ArrayDeque<>());
         }
         for (int i = 0; i < arrayB.length; i++) {
             if (map.containsKey(arrayB[i])) {
@@ -37,7 +36,7 @@ private static Map<Integer, Deque<HeapNode>> makeLists(int[] arrayA, int[] array
     }
 
     private static Range getSmallestRange(Map<Integer, Deque<HeapNode>> map) {
-        Queue<HeapNode> minHeap = new PriorityQueue<>(new NodeComparator());
+        Queue<HeapNode> minHeap = new PriorityQueue<>((hn1, hn2) -> hn1.index - hn2.index);
 
         Range currRange = new Range(Integer.MAX_VALUE, Integer.MIN_VALUE);
 

Chp. 17 - More Problems (Hard)/_17_18_Shortest_Supersequence/ShortestSupersequence.java

@@ -13,6 +13,7 @@ public static void main(String[] args) {
     private static void test(int[] arrayA, int[] arrayB) {
         System.out.println(Arrays.toString(arrayA));
         System.out.println(Arrays.toString(arrayB));
-        ShortestSupersequence.shortest(arrayA, arrayB);
+        Range range = ShortestSupersequence.shortest(arrayA, arrayB);
+        System.out.println("Range: " + range);
     }
 }