Added Pretty Display method and BSTRecursiveGenericTests.java

src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java

@@ -13,6 +13,7 @@
  * </p>
  *
  * @author [Madhur Panwar](<a href="https://github.com/mdrpanwar">git-Madhur Panwar</a>)
+ * @author [Udaya Krishnan M](<a href="https://github.com/UdayaKrishnanM/">git-Udaya Krishnan M</a>) {added prettyDisplay() method}
  */
 public class BSTRecursiveGeneric<T extends Comparable<T>> {
 
@@ -28,6 +29,29 @@ public BSTRecursiveGeneric() {
         root = null;
     }
 
+    /**
+     * Displays the tree is a structed format
+     */
+    public void prettyDisplay() {
+        prettyDisplay(root, 0);
+    }
+
+    private void prettyDisplay(Node<T> node, int level) {
+        if (node == null) {
+            return;
+        }
+        prettyDisplay(node.right, level + 1);
+        if (level != 0) {
+            for (int i = 0; i < level - 1; i++) {
+                System.out.print("|\t");
+            }
+            System.out.println("|---->" + node.data);
+        } else {
+            System.out.println(node.data);
+        }
+        prettyDisplay(node.left, level + 1);
+    }
+
     /**
      * main function for testing
      */
@@ -38,7 +62,12 @@ public static void main(String[] args) {
 
         integerTree.add(5);
         integerTree.add(10);
-        integerTree.add(9);
+        integerTree.add(-9);
+        integerTree.add(4);
+        integerTree.add(3);
+        integerTree.add(1);
+        System.out.println("Pretty Display of current tree is:");
+        integerTree.prettyDisplay();
         assert !integerTree.find(4)
             : "4 is not yet present in BST";
         assert integerTree.find(10)
@@ -54,16 +83,21 @@ public static void main(String[] args) {
         assert integerTree.find(70)
             : "70 was inserted but not found";
         /*
-     Will print in following order
-     5 10 20 70
+            Will print in following order
+            5 10 20 70
          */
+        System.out.println("Pretty Display of current tree is:");
+        integerTree.prettyDisplay();
         integerTree.inorder();
+        System.out.println("Pretty Display of current tree is:");
+        integerTree.prettyDisplay();
         System.out.println();
         System.out.println("Testing for string data...");
         // String
         BSTRecursiveGeneric<String> stringTree = new BSTRecursiveGeneric<String>();
 
         stringTree.add("banana");
+        stringTree.add("apple");
         stringTree.add("pineapple");
         stringTree.add("date");
         assert !stringTree.find("girl")
@@ -80,11 +114,15 @@ public static void main(String[] args) {
         stringTree.add("hills");
         assert stringTree.find("hills")
             : "hills was inserted but not found";
+        System.out.println("Pretty Display of current tree is:");
+        stringTree.prettyDisplay();
         /*
      Will print in following order
      banana hills india pineapple
          */
         stringTree.inorder();
+        System.out.println("Pretty Display of current tree is:");
+        stringTree.prettyDisplay();
     }
 
     /**

src/test/java/com/thealgorithms/datastructures/trees/BSTRecursiveGenericTest.java

@@ -0,0 +1,169 @@
+package com.thealgorithms.datastructures.trees;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for BSTRecursiveGeneric class.
+ * Covers insertion, deletion, search, traversal, sorting, and display.
+ *
+ * Author: Udaya Krishnan M
+ * GitHub: https://github.com/UdayaKrishnanM/
+ */
+class BSTRecursiveGenericTest {
+
+    private BSTRecursiveGeneric<Integer> intTree;
+    private BSTRecursiveGeneric<String> stringTree;
+
+    /**
+     * Initializes test trees before each test.
+     */
+    @BeforeEach
+    void setUp() {
+        intTree = new BSTRecursiveGeneric<>();
+        stringTree = new BSTRecursiveGeneric<>();
+    }
+
+    /**
+     * Tests insertion and search of integer values.
+     */
+    @Test
+    void testAddAndFindInteger() {
+        intTree.add(10);
+        intTree.add(5);
+        intTree.add(15);
+        assertTrue(intTree.find(10));
+        assertTrue(intTree.find(5));
+        assertTrue(intTree.find(15));
+        assertFalse(intTree.find(20));
+    }
+
+    /**
+     * Tests insertion and search of string values.
+     */
+    @Test
+    void testAddAndFindString() {
+        stringTree.add("apple");
+        stringTree.add("banana");
+        stringTree.add("cherry");
+        assertTrue(stringTree.find("banana"));
+        assertFalse(stringTree.find("date"));
+    }
+
+    /**
+     * Tests deletion of existing and non-existing elements.
+     */
+    @Test
+    void testRemoveElements() {
+        intTree.add(10);
+        intTree.add(5);
+        intTree.add(15);
+        assertTrue(intTree.find(5));
+        intTree.remove(5);
+        assertFalse(intTree.find(5));
+        intTree.remove(100); // non-existent
+        assertFalse(intTree.find(100));
+    }
+
+    /**
+     * Tests inorder traversal output.
+     */
+    @Test
+    void testInorderTraversal() {
+        intTree.add(20);
+        intTree.add(10);
+        intTree.add(30);
+        intTree.inorder(); // visually verify output
+        assertTrue(true);
+    }
+
+    /**
+     * Tests preorder traversal output.
+     */
+    @Test
+    void testPreorderTraversal() {
+        intTree.add(20);
+        intTree.add(10);
+        intTree.add(30);
+        intTree.preorder(); // visually verify output
+        assertTrue(true);
+    }
+
+    /**
+     * Tests postorder traversal output.
+     */
+    @Test
+    void testPostorderTraversal() {
+        intTree.add(20);
+        intTree.add(10);
+        intTree.add(30);
+        intTree.postorder(); // visually verify output
+        assertTrue(true);
+    }
+
+    /**
+     * Tests inorderSort returns sorted list.
+     */
+    @Test
+    void testInorderSort() {
+        intTree.add(30);
+        intTree.add(10);
+        intTree.add(20);
+        List<Integer> sorted = intTree.inorderSort();
+        assertEquals(List.of(10, 20, 30), sorted);
+    }
+
+    /**
+     * Tests prettyDisplay method for visual tree structure.
+     */
+    @Test
+    void testPrettyDisplay() {
+        intTree.add(50);
+        intTree.add(30);
+        intTree.add(70);
+        intTree.add(20);
+        intTree.add(40);
+        intTree.add(60);
+        intTree.add(80);
+        intTree.prettyDisplay(); // visually verify output
+        assertTrue(true);
+    }
+
+    /**
+     * Tests edge case: empty tree.
+     */
+    @Test
+    void testEmptyTree() {
+        assertFalse(intTree.find(1));
+        List<Integer> sorted = intTree.inorderSort();
+        assertTrue(sorted.isEmpty());
+    }
+
+    /**
+     * Tests edge case: single node tree.
+     */
+    @Test
+    void testSingleNodeTree() {
+        intTree.add(42);
+        assertTrue(intTree.find(42));
+        intTree.remove(42);
+        assertFalse(intTree.find(42));
+    }
+
+    /**
+     * Tests duplicate insertions.
+     */
+    @Test
+    void testDuplicateInsertions() {
+        intTree.add(10);
+        intTree.add(10);
+        intTree.add(10);
+        List<Integer> sorted = intTree.inorderSort();
+        assertEquals(List.of(10), sorted); // assuming duplicates are ignored
+    }
+}