updated

Author: Krishnan M

src/test/java/com/thealgorithms/tree/BinarySearchTree.java

@@ -88,6 +88,36 @@ void testPrettyDisplay() {
         bst.prettyDisplay();
         assertTrue(true, "Pretty display executed successfully");
     }
+    
+    /**
+     * Tests insertion of negative values into the BST.
+     * Verifies that the tree is not empty and remains balanced.
+     */
+    @Test
+    void testInsertNegativeValues() {
+        BinarySearchTree bst = new BinarySearchTree();
+        int[] negativeValues = {-10, -20, -5, -15};
+        bst.populate(negativeValues);
+        assertFalse(bst.isEmpty(), "BST should not be empty after inserting negative values");
+        assertTrue(bst.balanced(), "BST with negative values should be balanced");
+    }
+
+    /**
+     * Tests insertion of duplicate values into the BST.
+     * Verifies that the tree handles duplicates (either inserts or ignores them).
+     * Note: Current BST implementation inserts duplicates to the right.
+     */
+    @Test
+    void testInsertDuplicateValues() {
+        BinarySearchTree bst = new BinarySearchTree();
+        int[] valuesWithDuplicates = {10, 20, 10, 30, 20};
+        bst.populate(valuesWithDuplicates);
+        assertFalse(bst.isEmpty(), "BST should not be empty after inserting duplicates");
+
+        // Optional: Check structure manually via traversal
+        bst.inOrder(); // Output can be visually verified
+        assertTrue(true, "BST handled duplicate values (check logic if duplicates are allowed)");
+    }
 
     /**
      * Tests balanced population using sorted array.

src/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java

@@ -1,7 +1,6 @@
 package com.thealgorithms.tree;
 
 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 org.junit.jupiter.api.BeforeEach;
@@ -51,37 +50,6 @@ void testUpdateNodeValue() {
         assertEquals(100, hld.queryMaxInPath(4, 5), "Updated value should be reflected in query");
     }
 
-    /**
-     * Tests insertion of negative values into the BST.
-     * Verifies that the tree is not empty and remains balanced.
-     */
-    @Test
-    void testInsertNegativeValues() {
-        BinarySearchTree bst = new BinarySearchTree();
-        int[] negativeValues = {-10, -20, -5, -15};
-        bst.populate(negativeValues);
-        assertFalse(bst.isEmpty(), "BST should not be empty after inserting negative values");
-        assertTrue(bst.balanced(), "BST with negative values should be balanced");
-    }
-
-    /**
-     * Tests insertion of duplicate values into the BST.
-     * Verifies that the tree handles duplicates (either inserts or ignores them).
-     * Note: Current BST implementation inserts duplicates to the right.
-     */
-    @Test
-    void testInsertDuplicateValues() {
-        BinarySearchTree bst = new BinarySearchTree();
-        int[] valuesWithDuplicates = {10, 20, 10, 30, 20};
-        bst.populate(valuesWithDuplicates);
-        assertFalse(bst.isEmpty(), "BST should not be empty after inserting duplicates");
-
-        // Optional: Check structure manually via traversal
-        bst.inOrder(); // Output can be visually verified
-        assertTrue(true, "BST handled duplicate values (check logic if duplicates are allowed)");
-    }
-
-
     /**
      * Tests the maximum value query in a skewed tree structure.
      */