From 6af307014d06c1440a6f43cf6652a20acf5850c7 Mon Sep 17 00:00:00 2001
From: Mulla Arsiya Tasleem <2400090250@kluniversity.in>
Date: Thu, 20 Nov 2025 14:50:24 +0530
Subject: [PATCH 1/2] Implement Binary Search Tree with basic operations

This class implements a Binary Search Tree with methods for insertion, deletion, and traversal (inorder, preorder, postorder). It also includes a main method for user interaction to perform these operations.
---
 .../trees/BinarySearchTree.java               | 117 ++++++++++++++++++
 1 file changed, 117 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java b/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java
new file mode 100644
index 000000000000..34930c30484d
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java
@@ -0,0 +1,117 @@
+import java.util.Scanner;
+
+public class BinarySearchTree {
+
+    static class Node {
+        int key;
+        Node left, right;
+        Node(int k) {
+            key = k;
+        }
+    }
+
+    Node root;
+
+    public void insert(int key) {
+        root = insertRec(root, key);
+    }
+
+    private Node insertRec(Node node, int key) {
+        if (node == null) return new Node(key);
+        if (key < node.key) node.left = insertRec(node.left, key);
+        else node.right = insertRec(node.right, key);
+        return node;
+    }
+
+    public void delete(int key) {
+        root = deleteRec(root, key);
+    }
+
+    private Node deleteRec(Node node, int key) {
+        if (node == null) return node;
+        if (key < node.key) node.left = deleteRec(node.left, key);
+        else if (key > node.key) node.right = deleteRec(node.right, key);
+        else {
+            if (node.left == null) return node.right;
+            if (node.right == null) return node.left;
+            node.key = minValue(node.right);
+            node.right = deleteRec(node.right, node.key);
+        }
+        return node;
+    }
+
+    private int minValue(Node node) {
+        int min = node.key;
+        while (node.left != null) {
+            min = node.left.key;
+            node = node.left;
+        }
+        return min;
+    }
+
+    public void inorder() {
+        inorderRec(root);
+        System.out.println();
+    }
+
+    private void inorderRec(Node node) {
+        if (node == null) return;
+        inorderRec(node.left);
+        System.out.print(node.key + " ");
+        inorderRec(node.right);
+    }
+
+    public void preorder() {
+        preorderRec(root);
+        System.out.println();
+    }
+
+    private void preorderRec(Node node) {
+        if (node == null) return;
+        System.out.print(node.key + " ");
+        preorderRec(node.left);
+        preorderRec(node.right);
+    }
+
+    public void postorder() {
+        postorderRec(root);
+        System.out.println();
+    }
+
+    private void postorderRec(Node node) {
+        if (node == null) return;
+        postorderRec(node.left);
+        postorderRec(node.right);
+        System.out.print(node.key + " ");
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        BinarySearchTree bst = new BinarySearchTree();
+
+        while (true) {
+            System.out.println("1.Insert  2.Delete  3.Inorder  4.Preorder  5.Postorder  6.Exit");
+            int ch = sc.nextInt();
+
+            if (ch == 1) {
+                System.out.print("Enter value: ");
+                int v = sc.nextInt();
+                bst.insert(v);
+            } else if (ch == 2) {
+                System.out.print("Enter value to delete: ");
+                int v = sc.nextInt();
+                bst.delete(v);
+            } else if (ch == 3) {
+                bst.inorder();
+            } else if (ch == 4) {
+                bst.preorder();
+            } else if (ch == 5) {
+                bst.postorder();
+            } else if (ch == 6) {
+                break;
+            } else {
+                System.out.println("Invalid choice");
+            }
+        }
+    }
+}

From 430be4d58327ce4215a71caa50e3f32b580ffbbc Mon Sep 17 00:00:00 2001
From: Mulla Arsiya Tasleem <2400090250@kluniversity.in>
Date: Thu, 20 Nov 2025 15:03:47 +0530
Subject: [PATCH 2/2] Refactor insert and delete methods for clarity

---
 .../trees/BinarySearchTree.java               | 111 ++++++++++++------
 1 file changed, 74 insertions(+), 37 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java b/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java
index 34930c30484d..b656fe8a2b68 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/BinarySearchTree.java
@@ -17,10 +17,18 @@ public void insert(int key) {
     }
 
     private Node insertRec(Node node, int key) {
-        if (node == null) return new Node(key);
-        if (key < node.key) node.left = insertRec(node.left, key);
-        else node.right = insertRec(node.right, key);
-        return node;
+        if (node == null) {
+            return new Node(key);
+        } 
+        else {
+            if (key < node.key) {
+                node.left = insertRec(node.left, key);
+            } 
+            else {
+                node.right = insertRec(node.right, key);
+            }
+            return node;
+        }
     }
 
     public void delete(int key) {
@@ -28,16 +36,32 @@ public void delete(int key) {
     }
 
     private Node deleteRec(Node node, int key) {
-        if (node == null) return node;
-        if (key < node.key) node.left = deleteRec(node.left, key);
-        else if (key > node.key) node.right = deleteRec(node.right, key);
+        if (node == null) {
+            return node;
+        } 
         else {
-            if (node.left == null) return node.right;
-            if (node.right == null) return node.left;
-            node.key = minValue(node.right);
-            node.right = deleteRec(node.right, node.key);
+            if (key < node.key) {
+                node.left = deleteRec(node.left, key);
+            } 
+            else if (key > node.key) {
+                node.right = deleteRec(node.right, key);
+            } 
+            else {
+                if (node.left == null) {
+                    return node.right;
+                } 
+                else {
+                    if (node.right == null) {
+                        return node.left;
+                    } 
+                    else {
+                        node.key = minValue(node.right);
+                        node.right = deleteRec(node.right, node.key);
+                    }
+                }
+            }
+            return node;
         }
-        return node;
     }
 
     private int minValue(Node node) {
@@ -55,10 +79,11 @@ public void inorder() {
     }
 
     private void inorderRec(Node node) {
-        if (node == null) return;
-        inorderRec(node.left);
-        System.out.print(node.key + " ");
-        inorderRec(node.right);
+        if (node != null) {
+            inorderRec(node.left);
+            System.out.print(node.key + " ");
+            inorderRec(node.right);
+        }
     }
 
     public void preorder() {
@@ -67,10 +92,11 @@ public void preorder() {
     }
 
     private void preorderRec(Node node) {
-        if (node == null) return;
-        System.out.print(node.key + " ");
-        preorderRec(node.left);
-        preorderRec(node.right);
+        if (node != null) {
+            System.out.print(node.key + " ");
+            preorderRec(node.left);
+            preorderRec(node.right);
+        }
     }
 
     public void postorder() {
@@ -79,10 +105,11 @@ public void postorder() {
     }
 
     private void postorderRec(Node node) {
-        if (node == null) return;
-        postorderRec(node.left);
-        postorderRec(node.right);
-        System.out.print(node.key + " ");
+        if (node != null) {
+            postorderRec(node.left);
+            postorderRec(node.right);
+            System.out.print(node.key + " ");
+        }
     }
 
     public static void main(String[] args) {
@@ -97,20 +124,30 @@ public static void main(String[] args) {
                 System.out.print("Enter value: ");
                 int v = sc.nextInt();
                 bst.insert(v);
-            } else if (ch == 2) {
-                System.out.print("Enter value to delete: ");
-                int v = sc.nextInt();
-                bst.delete(v);
-            } else if (ch == 3) {
-                bst.inorder();
-            } else if (ch == 4) {
-                bst.preorder();
-            } else if (ch == 5) {
-                bst.postorder();
-            } else if (ch == 6) {
-                break;
             } else {
-                System.out.println("Invalid choice");
+                if (ch == 2) {
+                    System.out.print("Enter value to delete: ");
+                    int v = sc.nextInt();
+                    bst.delete(v);
+                } else {
+                    if (ch == 3) {
+                        bst.inorder();
+                    } else {
+                        if (ch == 4) {
+                            bst.preorder();
+                        } else {
+                            if (ch == 5) {
+                                bst.postorder();
+                            } else {
+                                if (ch == 6) {
+                                    break;
+                                } else {
+                                    System.out.println("Invalid choice");
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }