From 94489a20ee2a85894bdee7dd5e6b14b69f63dca0 Mon Sep 17 00:00:00 2001
From: aaryab27 <aaryabhadale27@gmail.com>
Date: Mon, 6 Oct 2025 22:25:13 +0530
Subject: [PATCH 1/2] Added the implementation of insertion and traversal of
 Binary Search Tree

---
 .../thealgorithms/tree/BinarySearchTree.java  | 94 +++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/tree/BinarySearchTree.java

diff --git a/src/main/java/com/thealgorithms/tree/BinarySearchTree.java b/src/main/java/com/thealgorithms/tree/BinarySearchTree.java
new file mode 100644
index 000000000000..d15c345d61df
--- /dev/null
+++ b/src/main/java/com/thealgorithms/tree/BinarySearchTree.java
@@ -0,0 +1,94 @@
+package com.thealgorithms.tree;
+import java.util.*;
+/*
+ * A simple implementation of a Binary Search Tree (BST) in Java.
+ * Supports insertion of integer values and tree traversals: inorder, preorder, and postorder.
+ */
+public class BinarySearchTree {
+
+  //node class
+  static class node {
+    int data;
+    node left;
+    node right;
+
+    node(int d) {
+      this.data = d;
+    }
+  }
+
+  //insert value into BST
+  public static node insert_recurssive(node root, int d) {
+    if (root == null) {
+      root = new node(d);
+      return root;
+    }
+    if (root.data > d) {
+      //left subtree
+      root.left = insert_recurssive(root.left, d);
+    } else {
+      //right subtree
+      root.right = insert_recurssive(root.right, d);
+    }
+    return root;
+  }
+
+  //inorder traversal
+  public static void inorder(node root) {
+    if (root == null) {
+      return;
+    }
+    inorder(root.left);
+    System.out.print(root.data + " ");
+    inorder(root.right);
+  }
+
+  //postorder traversal
+  public static void postorder(node root) {
+
+    if (root == null) {
+      return;
+    }
+    postorder(root.left);
+    postorder(root.right);
+    System.out.print(root.data + " ");
+  }
+
+  //preorder traversal
+  public static void preorder(node root) {
+
+    if (root == null) {
+      return;
+    }
+    System.out.print(root.data + " ");
+    preorder(root.left);
+    preorder(root.right);
+  }
+
+  //main method
+  public static void main(String[] args) {
+
+    Scanner sc = new Scanner(System.in);
+    System.out.println("Enter the number of integer elements");
+    int n = sc.nextInt();
+
+    int values[] = new int[n];
+    System.out.println("Enter " + n + " values:-");
+    for (int i = 0; i < n; i++)
+      values[i] = sc.nextInt();
+    sc.close();
+    node root = null;
+    //insert values into BST
+    for (int i = 0; i < values.length; i++) {
+      root = insert_recurssive(root, values[i]);
+    }
+
+    //traversal of BST
+    System.out.println("Inorder Traversal is:-");
+    inorder(root);
+    System.out.println("\nPostorder Traversal is:-");
+    postorder(root);
+    System.out.println("\nPreorder Traversal is:-");
+    preorder(root);
+  }
+}
\ No newline at end of file

From aa53fb93f5ef00e1e9a8b6798230d11b07231acd Mon Sep 17 00:00:00 2001
From: aaryab27 <aaryabhadale27@gmail.com>
Date: Sat, 18 Oct 2025 16:00:15 +0530
Subject: [PATCH 2/2] Added the test cases to the binary Search tree

---
 .../thealgorithms/tree/BinarySearchTree.java  | 171 ++++++++++--------
 1 file changed, 96 insertions(+), 75 deletions(-)

diff --git a/src/main/java/com/thealgorithms/tree/BinarySearchTree.java b/src/main/java/com/thealgorithms/tree/BinarySearchTree.java
index d15c345d61df..8f54f7dba929 100644
--- a/src/main/java/com/thealgorithms/tree/BinarySearchTree.java
+++ b/src/main/java/com/thealgorithms/tree/BinarySearchTree.java
@@ -1,94 +1,115 @@
 package com.thealgorithms.tree;
-import java.util.*;
-/*
+
+import java.util.Scanner;
+
+/**
  * A simple implementation of a Binary Search Tree (BST) in Java.
  * Supports insertion of integer values and tree traversals: inorder, preorder, and postorder.
  */
 public class BinarySearchTree {
 
-  //node class
-  static class node {
-    int data;
-    node left;
-    node right;
+    // Node class
+    static class Node {
+        int data;
+        Node left, right;
 
-    node(int d) {
-      this.data = d;
+        Node(int d) {
+            this.data = d;
+        }
     }
-  }
 
-  //insert value into BST
-  public static node insert_recurssive(node root, int d) {
-    if (root == null) {
-      root = new node(d);
-      return root;
-    }
-    if (root.data > d) {
-      //left subtree
-      root.left = insert_recurssive(root.left, d);
-    } else {
-      //right subtree
-      root.right = insert_recurssive(root.right, d);
+    // Insert value into BST recursively
+    public static Node insertRecursive(Node root, int d) {
+        if (root == null) {
+            return new Node(d);
+        }
+        if (d < root.data) {
+            root.left = insertRecursive(root.left, d);
+        } else {
+            root.right = insertRecursive(root.right, d);
+        }
+        return root;
     }
-    return root;
-  }
 
-  //inorder traversal
-  public static void inorder(node root) {
-    if (root == null) {
-      return;
+    // Inorder traversal
+    public static void inorder(Node root) {
+        if (root == null) return;
+        inorder(root.left);
+        System.out.print(root.data + " ");
+        inorder(root.right);
     }
-    inorder(root.left);
-    System.out.print(root.data + " ");
-    inorder(root.right);
-  }
 
-  //postorder traversal
-  public static void postorder(node root) {
+    // Preorder traversal
+    public static void preorder(Node root) {
+        if (root == null) return;
+        System.out.print(root.data + " ");
+        preorder(root.left);
+        preorder(root.right);
+    }
 
-    if (root == null) {
-      return;
+    // Postorder traversal
+    public static void postorder(Node root) {
+        if (root == null) return;
+        postorder(root.left);
+        postorder(root.right);
+        System.out.print(root.data + " ");
     }
-    postorder(root.left);
-    postorder(root.right);
-    System.out.print(root.data + " ");
-  }
 
-  //preorder traversal
-  public static void preorder(node root) {
+    // Main method
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
 
-    if (root == null) {
-      return;
-    }
-    System.out.print(root.data + " ");
-    preorder(root.left);
-    preorder(root.right);
-  }
-
-  //main method
-  public static void main(String[] args) {
-
-    Scanner sc = new Scanner(System.in);
-    System.out.println("Enter the number of integer elements");
-    int n = sc.nextInt();
-
-    int values[] = new int[n];
-    System.out.println("Enter " + n + " values:-");
-    for (int i = 0; i < n; i++)
-      values[i] = sc.nextInt();
-    sc.close();
-    node root = null;
-    //insert values into BST
-    for (int i = 0; i < values.length; i++) {
-      root = insert_recurssive(root, values[i]);
-    }
+        System.out.println("Enter the number of elements:");
+        int n = sc.nextInt();
+
+        int[] values = new int[n];
+        System.out.println("Enter " + n + " values:");
+        for (int i = 0; i < n; i++) {
+            values[i] = sc.nextInt();
+        }
+        sc.close();
+
+        Node root = null;
+        for (int value: values) {
+            root = insertRecursive(root, value);
+        }
+
+        // Traversal outputs
+        System.out.println("Inorder Traversal:");
+        inorder(root);
 
-    //traversal of BST
-    System.out.println("Inorder Traversal is:-");
-    inorder(root);
-    System.out.println("\nPostorder Traversal is:-");
-    postorder(root);
-    System.out.println("\nPreorder Traversal is:-");
-    preorder(root);
-  }
+        System.out.println("\nPostorder Traversal:");
+        postorder(root);
+
+        System.out.println("\nPreorder Traversal:");
+        preorder(root);
+
+        //   Test Cases
+        System.out.println("\n\nRunning basic test case...");
+
+        int[] testValues = {
+            10,
+            5,
+            15,
+            3,
+            7,
+            12,
+            18
+        };
+        Node testRoot = null;
+        for (int val: testValues) {
+            testRoot = insertRecursive(testRoot, val);
+        }
+
+        System.out.print("Expected Inorder:   3 5 7 10 12 15 18\nActual:            ");
+        inorder(testRoot);
+
+        System.out.print("\nExpected Preorder:  10 5 3 7 15 12 18\nActual:            ");
+        preorder(testRoot);
+
+        System.out.print("\nExpected Postorder: 3 7 5 12 18 15 10\nActual:            ");
+        postorder(testRoot);
+
+        System.out.println("\nBasic test case complete.");
+    }
 }
\ No newline at end of file