Added the test cases to the binary Search tree

Author: aaryab27

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.");
+    }
 }