Updated 1 solution

Author: RodneyShag

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

@@ -25,7 +25,7 @@ private static TreeNode leftMostChild(TreeNode node) {
         return result;
     }
 
-    /* Finds the parent (well, ancestor) that has treeNode in its left subtree. Returns null if such parent doesn't exist */
+    // Finds the parent (well, ancestor) that has treeNode in its left subtree. Returns null if such parent doesn't exist
     private static TreeNode properParent(TreeNode node) {
         if (node == null) {
             return null;
@@ -39,3 +39,6 @@ private static TreeNode properParent(TreeNode node) {
         return parent;
     }
 }
+
+// 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

Chp. 04 - Trees and Graphs/_4_11_Random_Node/BST.java

@@ -2,26 +2,31 @@
 
 class BST {
     Node root = null;
+    RandomizedCollection<Node> collection = new RandomizedCollection<>();
 
     public void insert(int value) {
+        Node item = new Node(value);
+        
+        // Update collection
+        collection.add(item);
+
+        // Update tree
         if (root == null) {
-            root = new Node(value);
+            root = item;
             return;
         }
-
         Node curr = root;
         while (true) {
-            curr.size++;
             if (value <= curr.value) {
                 if (curr.left == null) {
-                    curr.left = new Node(value);
+                    curr.left = item;
                     return;
                 } else {
                     curr = curr.left;
                 }
             } else {
                 if (curr.right == null) {
-                    curr.right = new Node(value);
+                    curr.right = item;
                     return;
                 } else {
                     curr = curr.right;
@@ -45,21 +50,14 @@ public Node find(int value) {
     }
 
     public Node getRandomNode() {
-        if (root == null) {
-            return null;
-        }
-        int randomNumber = (int) (Math.random() * root.size);
-        return getRandomHelper(root, randomNumber);
-    }
-
-    private static Node getRandomHelper(Node node, int num) {
-        int leftSize = (node.left == null) ? 0 : node.left.size;
-        if (num < leftSize) {
-            return getRandomHelper(node.left, num);
-        } else if (num == leftSize) {
-            return node;
-        } else {
-            return getRandomHelper(node.right, num - leftSize - 1);
-        }
+        return collection.getRandom();
     }
+    
+    // delete() not coded
+    //
+    // - To delete, can find "inorder successor" from node to delete, and put that in deleted node's spot
+    // - For "Inorder Successor" code, see Cracking the Coding Interview question 4.6
+    // - For Deletion, see 1-3 at: https://www.geeksforgeeks.org/binary-search-tree-set-2-delete/
 }
+
+// Time Complexity: O(1) for getRandomNode()

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

@@ -4,13 +4,30 @@ class Node {
     int value;
     Node left;
     Node right;
-    int size;
 
     Node(int value) {
         this.value = value;
         left = null;
         right = null;
-        size = 1; // This will count size of the entire tree rooted at this Node.
+    }
+
+    @Override
+    public boolean equals(Object other) { // must take an "Object" as a parameter, not a
+                                          // "Node", so that it overrides the .equals method
+        if (other == this) {
+            return true;
+        } else if (other == null || !(other instanceof Node)) {
+            return false;
+        }
+        Node otherNode = (Node) other;
+        return this.value == otherNode.value
+            && this.left.equals(otherNode.left)
+            && this.right.equals(otherNode.right);
+    }
+
+    @Override
+    public int hashCode() {
+        return value; // since only using 1 int, won't be multiplying by primes.
     }
 
     @Override

Chp. 04 - Trees and Graphs/_4_11_Random_Node/RandomizedCollection.java

@@ -0,0 +1,56 @@
+package _4_11_Random_Node;
+
+import java.util.*;
+
+public class RandomizedCollection<T> {
+    Random rand = new Random();
+    List<T> list = new ArrayList<>();
+    Map<T, Set<Integer>> valToIndices = new HashMap<>();
+
+    public void add(T item) {
+        // update Map
+        if (!valToIndices.containsKey(item)) {
+            valToIndices.put(item, new HashSet<>());
+        }
+        valToIndices.get(item).add(list.size());
+
+        // update List
+        list.add(item);
+
+        return;
+    }
+
+    public boolean remove(T item) {
+        if (!valToIndices.containsKey(item) || valToIndices.get(item).isEmpty()) {
+            return false;
+        }
+
+        int indexToRemove = valToIndices.get(item).iterator().next();
+        T itemLast = list.get(list.size() - 1);
+
+        // update List
+        list.set(indexToRemove, itemLast);
+        list.remove(list.size() - 1);
+
+        // update Map: remove overwritten index from set
+        valToIndices.get(item).remove(indexToRemove);
+
+        // update Map: update the moved number's index
+        valToIndices.get(itemLast).add(indexToRemove);                              
+        valToIndices.get(itemLast).remove(list.size());
+
+        return true;
+    }
+
+    public boolean contains(T item) {
+        return valToIndices.containsKey(item) && !valToIndices.get(item).isEmpty();
+    }
+
+    public T getRandom() {
+        if (list.isEmpty()) {
+            throw new Error("Collection is empty");
+        }
+        int index = rand.nextInt(list.size());
+        return list.get(index);
+    }
+}

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

@@ -4,7 +4,7 @@ public class Tester {
     public static void main(String[] args) {
         System.out.println("*** Test 4.11: RandomNode\n");
         BST bst = new BST();
-        int[]array = { 1, 0, 6, 2, 3, 9, 4, 5, 8, 7 };
+        int[] array = { 1, 0, 6, 2, 3, 9, 4, 5, 8, 7 };
         for (int num : array) {
             bst.insert(num);
         }