Merge pull request #3253 from asturcon/tutorials/binaryTreeJava

BAEL-1339 - Implementing a binary tree in Java

core-java/src/main/java/com/baeldung/tree/BinaryTree.java

@@ -16,29 +16,23 @@ public class BinaryTree {
             return;
         }
 
-        Node parent = root;
+        addRecursive(root, value);
-        Node current = root;
+    }
 
-        while (true) {
+    private Node addRecursive(Node current, int value) {
 
-            if (newNode.value < parent.value) {
+        if (current == null) {
-                current = parent.left;
+            return new Node(value);
-
-                if (current == null) {
-                    parent.left = newNode;
-                    break;
-                }
-            } else {
-                current = parent.right;
-
-                if (current == null) {
-                    parent.right = newNode;
-                    break;
-                }
-            }
-
-            parent = current;
         }
+
+        if (value < current.value) {
+            current.left = addRecursive(current.left, value);
+        } else {
+            current.right = addRecursive(current.right, value);
+        }
+
+        return current;
+
     }
 
     public boolean isEmpty() {
@@ -46,115 +40,69 @@ public class BinaryTree {
     }
 
     public boolean containsNode(int value) {
-
+        return containsNodeRecursive(root, value);
-        Node current = root;
-
-        while (current != null) {
-
-            if (value == current.value) {
-                return true;
-            }
-
-            if (value < current.value) {
-                current = current.left;
-            } else {
-                current = current.right;
-            }
-
-        }
-
-        return false;
     }
 
-    public void delete(int value) {
+    private boolean containsNodeRecursive(Node current, int value) {
 
-        Node current = root;
+        if (current == null) {
-        Node parent = root;
+            return false;
-        Node nodeToDelete = null;
+        } else if (value == current.value) {
-        boolean isLeftChild = false;
+            return true;
-
+        } else if (value < current.value) {
-        while (nodeToDelete == null && current != null) {
+            return containsNodeRecursive(current.left, value);
-
+        } else {
-            if (value == current.value) {
+            return containsNodeRecursive(current.right, value);
-                nodeToDelete = current;
-            } else if (value < current.value) {
-                parent = current;
-                current = current.left;
-                isLeftChild = true;
-            } else {
-                parent = current;
-                current = current.right;
-                isLeftChild = false;
-            }
-
-        }
-
-        if (nodeToDelete == null) {
-            return;
-        }
-
-        // Case 1: no children
-        if (nodeToDelete.left == null && nodeToDelete.right == null) {
-            if (nodeToDelete == root) {
-                root = null;
-            } else if (isLeftChild) {
-                parent.left = null;
-            } else {
-                parent.right = null;
-            }
-        }
-        // Case 2: only 1 child
-        else if (nodeToDelete.right == null) {
-            if (nodeToDelete == root) {
-                root = nodeToDelete.left;
-            } else if (isLeftChild) {
-                parent.left = nodeToDelete.left;
-            } else {
-                parent.right = nodeToDelete.left;
-            }
-        } else if (nodeToDelete.left == null) {
-            if (nodeToDelete == root) {
-                root = nodeToDelete.right;
-            } else if (isLeftChild) {
-                parent.left = nodeToDelete.right;
-            } else {
-                parent.right = nodeToDelete.right;
-            }
-        }
-        // Case 3: 2 children
-        else if (nodeToDelete.left != null && nodeToDelete.right != null) {
-            Node replacement = findReplacement(nodeToDelete);
-            if (nodeToDelete == root) {
-                root = replacement;
-            } else if (isLeftChild) {
-                parent.left = replacement;
-            } else {
-                parent.right = replacement;
-            }
         }
 
     }
 
-    private Node findReplacement(Node nodeToDelete) {
+    public void delete(int value) {
+        deleteRecursive(root, value);
+    }
 
-        Node replacement = nodeToDelete;
+    private Node deleteRecursive(Node current, int value) {
-        Node parentReplacement = nodeToDelete;
+        if (current == null) {
-        Node current = nodeToDelete.right;
+            return null;
-
-        while (current != null) {
-            parentReplacement = replacement;
-            replacement = current;
-            current = current.left;
         }
 
-        if (replacement != nodeToDelete.right) {
+        if (value == current.value) {
-            parentReplacement.left = replacement.right;
+            // Case 1: no children
-            replacement.right = nodeToDelete.right;
+            if (current.left == null && current.right == null) {
+                return null;
+            }
+
+            // Case 2: only 1 child
+            if (current.right == null) {
+                return current.left;
+            }
+
+            if (current.left == null) {
+                return current.right;
+            }
+
+            // Case 3: 2 children
+            int smallestValue = findSmallestValue(current.right);
+            current.value = smallestValue;
+            current.right = deleteRecursive(current.right, smallestValue);
+            return current;
+
+        } else if (value < current.value) {
+            current.left = deleteRecursive(current.left, value);
+            return current;
+        } else {
+            current.right = deleteRecursive(current.right, value);
+            return current;
+        }
+    }
+
+    private int findSmallestValue(Node root) {
+
+        if (root.left == null) {
+            return root.value;
         }
 
-        replacement.left = nodeToDelete.left;
+        return findSmallestValue(root.left);
-
-        return replacement;
     }
 
     public void traverseInOrder(Node node) {