Add AVL tests

Author: bcExpt1123

src/main/java/org/alda/Main.java

@@ -21,6 +21,7 @@
 import org.alda.structure.stack.linkedList.StackLinkedList;
 import org.alda.structure.tree.bst.BinarySearchTree;
 import org.alda.structure.tree.bst.bbt.AVL;
+import org.alda.structure.tree.bst.bbt.AVLTest;
 
 import java.util.Arrays;
 import java.util.List;
@@ -407,11 +408,6 @@ public static void testBST(){
     }
 
     public static void testAVL(){
-        AVL<Integer> avl = new AVL<>();
-        AVL.Node<Integer> root = null;
-        List<Integer> keys = Arrays.asList(10, 20, 30, 40, 50, 25);
-        for(Integer key : keys){
-            avl.insert(root, key);
-        }
+        AVLTest.main(null);
     }
 }

src/main/java/org/alda/common/Utils.java

@@ -0,0 +1,16 @@
+package org.alda.common;
+
+import java.util.Arrays;
+
+public class Utils {
+    public static String intArrToStr(int[] arr, String delimiter) {
+        return Arrays.stream(arr)
+                .mapToObj(String::valueOf)
+                .reduce((a, b) -> a + delimiter + b)
+                .orElse("");
+    }
+
+    public static String intArrToStr(int[] arr) {
+        return intArrToStr(arr, ", ");
+    }
+}

src/main/java/org/alda/structure/tree/bst/bbt/AVL.java

@@ -43,8 +43,10 @@ public Node<T> insert(Node<T> root, T key) {
             return new Node<>(key);
         } else if (key.compareTo(root.key) < 0) {
             root.left = insert(root.left, key);
-        } else {
+        } else if (key.compareTo(root.key) > 0) {
             root.right = insert(root.right, key);
+        } else {
+            return root; // Duplicate keys not allowed
         }
 
         root.height = 1 + Math.max(getHeight(root.left), getHeight(root.right));
@@ -73,8 +75,8 @@ public Integer getHeight(Node<T> root) {
     }
 
     public Integer getBalance(Node<T> root) {
-        if(root == null) return 0;
-        return getHeight(root.left) + getHeight(root.right);
+        if (root == null) return 0;
+        return getHeight(root.left) - getHeight(root.right);
     }
 
     public Node<T> rotateRight(Node<T> z) {

src/main/java/org/alda/structure/tree/bst/bbt/AVLTest.java

@@ -0,0 +1,50 @@
+package org.alda.structure.tree.bst.bbt;
+
+import org.alda.common.Utils;
+
+public class AVLTest {
+    public static void main(String[] args) {
+        System.out.println("\n=== Initialize AVL Tree ===");
+        AVL<Integer> avl = new AVL<>();
+        AVL.Node<Integer> root = null;
+
+        // Insert elements to test rotations
+        int[] elements = {10, 20, 30, 40, 50, 25};
+
+        System.out.println("Actions: \n- Insert " + Utils.intArrToStr(elements));
+        for (int el : elements) {
+            root = avl.insert(root, el);
+        }
+
+        // Print tree in in-order
+        System.out.println("\nIn-order traversal:");
+        inOrder(root);
+
+        // Print tree structure
+        System.out.println("\n\nTree structure:");
+        printTree(root, "", true);
+    }
+
+    // In-order traversal (left-root-right)
+    public static <T extends Comparable<T>> void inOrder(AVL.Node<T> node) {
+        if (node != null) {
+            inOrder(node.left);
+            System.out.print(node.key + " ");
+            inOrder(node.right);
+        }
+    }
+
+    // Pretty-print the tree
+    public static <T extends Comparable<T>> void printTree(AVL.Node<T> node, String prefix, boolean isTail) {
+        if (node == null) return;
+
+        System.out.println(prefix + (isTail ? "└── " : "├── ") + node.key + " (h=" + node.height + ")");
+
+        if (node.left != null || node.right != null) {
+            if (node.right != null)
+                printTree(node.right, prefix + (isTail ? "    " : "│   "), node.left == null);
+            if (node.left != null)
+                printTree(node.left, prefix + (isTail ? "    " : "│   "), true);
+        }
+    }
+}

src/test/java/org/alda/common/UtilsTest.java

@@ -0,0 +1,42 @@
+package org.alda.common;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class UtilsTest {
+    @Test
+    void testNormalArray() {
+        int[] arr = {1, 2, 3, 4, 5};
+        String result = Utils.intArrToStr(arr, ",");
+        assertEquals("1,2,3,4,5", result);
+    }
+
+    @Test
+    void testSingleElementArray() {
+        int[] arr = {42};
+        String result = Utils.intArrToStr(arr, ",");
+        assertEquals("42", result);
+    }
+
+    @Test
+    void testEmptyArray() {
+        int[] arr = {};
+        String result = Utils.intArrToStr(arr, ",");
+        assertEquals("", result);
+    }
+
+    @Test
+    void testDifferentDelimiter() {
+        int[] arr = {10, 20, 30};
+        String result = Utils.intArrToStr(arr, " | ");
+        assertEquals("10 | 20 | 30", result);
+    }
+
+    @Test
+    void testNegativeNumbers() {
+        int[] arr = {-1, -2, -3};
+        String result = Utils.intArrToStr(arr, ";");
+        assertEquals("-1;-2;-3", result);
+    }
+}