Added AVL tree implementation with detailed comments

Author: amarmaurya-com

src/main/java/com/thealgorithms/tree/AVL.java

@@ -113,7 +113,6 @@ public List<Integer> postorderList() {
         return res;
     }
 
-
     /**
      * Recursive insert:
      * 1. Insert key like a normal BST
@@ -249,7 +248,6 @@ private Node balanceNode(Node node) {
         // Case 1: Left Left (LL)
         if (balance > 1 && getBalance(node.left) >= 0) return rightRotate(node);
 
-
         // Case 2: Left Right (LR)
         if (balance > 1 && getBalance(node.left) < 0) {
             node.left = leftRotate(node.left);
@@ -259,7 +257,6 @@ private Node balanceNode(Node node) {
         // Case 3: Right Right (RR)
         if (balance < -1 && getBalance(node.right) <= 0) return leftRotate(node);
 
-
         // Case 4: Right Left (RL)
         if (balance < -1 && getBalance(node.right) > 0) {
             node.right = rightRotate(node.right);

src/main/java/com/thealgorithms/tree/BST.java

@@ -184,7 +184,6 @@ public int findMax() {
         return current.key;
     }
 
-
     /**
      * Print inorder traversal (Left, Node, Right).
      * InOrder -> Left, key, Right
@@ -242,7 +241,7 @@ private void printPostorderRecursive(Node node) {
         System.out.print(node.key + " "); // node
     }
 
-        public List<Integer> inorderList() {
+    public List<Integer> inorderList() {
         List<Integer> result = new ArrayList<>();
         inorderToList(root, result);
         return result;
@@ -257,7 +256,6 @@ private void inorderToList(Node node, List<Integer> out) {
         inorderToList(node.right, out);
     }
 
-
     public List<Integer> preorderList() {
         List<Integer> result = new ArrayList<>();
         preorderToList(root, result);
@@ -301,15 +299,12 @@ public static void main(String[] args) {
         System.out.println("Preorder List: " + bst.preorderList());
         System.out.println("Postorder List: " + bst.postorderList());
 
-
         System.out.println("Search 40: " + bst.search(40)); // true
         System.out.println("Search 99: " + bst.search(99)); // false
 
-
         System.out.println("Min: " + bst.findMin()); // 20
         System.out.println("Max: " + bst.findMax()); // 80
 
-
         bst.delete(20);
         System.out.println("After deleting 20 (leaf): " + bst.inorderList());
 

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

@@ -91,11 +91,9 @@ private Node insertRecursive(Node node, int key) {
 
         if (key < node.key) {
             node.left = insertRecursive(node.left, key);
-        }
-        else if (key > node.key) {
+        } else if (key > node.key) {
             node.right = insertRecursive(node.right, key);
-        }
-        else {
+        } else {
             return node; // duplicates ignored
             }
 
@@ -110,11 +108,9 @@ private Node deleteRecursive(Node node, int key) {
 
         if (key < node.key) {
             node.left = deleteRecursive(node.left, key);
-        }
-        else if (key > node.key) {
+        } else if (key > node.key) {
             node.right = deleteRecursive(node.right, key);
-        }
-        else {
+        } else {
             if (node.left == null || node.right == null) {
                 Node temp = (node.left != null) ? node.left : node.right;
                 if (temp == null) {

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

@@ -27,7 +27,7 @@ private static class Node {
 
     // Root of the BST
     // the first of Node tree
-    //0->
+    // 0->
     private Node root;
 
     /** Create an empty BST. */
@@ -182,7 +182,6 @@ public int findMax() {
         return current.key;
     }
 
-
     /**
      * Print inorder traversal (Left, Node, Right).
      * InOrder -> Left, key, Right
@@ -197,9 +196,9 @@ private void printInorderRecursive(Node node) {
         if (node == null) {
             return;
         }
-        printInorderRecursive(node.left);      // left
-        System.out.print(node.key + " ");      // node
-        printInorderRecursive(node.right);     // right
+        printInorderRecursive(node.left); // left
+        System.out.print(node.key + " "); // node
+        printInorderRecursive(node.right); // right
     }
 
     /**
@@ -216,9 +215,9 @@ private void printPreorderRecursive(Node node) {
         if (node == null) {
             return;
         }
-        System.out.print(node.key + " ");      // node
-        printPreorderRecursive(node.left);     // left
-        printPreorderRecursive(node.right);    // right
+        System.out.print(node.key + " "); // node
+        printPreorderRecursive(node.left); // left
+        printPreorderRecursive(node.right); // right
     }
 
     /**
@@ -235,9 +234,9 @@ private void printPostorderRecursive(Node node) {
         if (node == null) {
             return;
         }
-        printPostorderRecursive(node.left);    // left
-        printPostorderRecursive(node.right);   // right
-        System.out.print(node.key + " ");      // node
+        printPostorderRecursive(node.left); // left
+        printPostorderRecursive(node.right); // right
+        System.out.print(node.key + " "); // node
     }
 
     public List<Integer> inorderList() {
@@ -255,7 +254,6 @@ private void inorderToList(Node node, List<Integer> out) {
         inorderToList(node.right, out);
     }
 
-
     public List<Integer> preorderList() {
         List<Integer> result = new ArrayList<>();
         preorderToList(root, result);