Added AVL tree implementation with detailed comments

Author: amarmaurya-com

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

@@ -4,22 +4,8 @@
 import java.util.List;
 import java.util.NoSuchElementException;
 
-/**
- * AVL (Adelson-Velsky and Landis) Tree is a self-balancing Binary Search Tree.
- *  Operations supported:
- *   - insert, delete, search
- *   - inorder, preorder, postorder traversal
- *   - findMin(), findMax()
- *
- * Properties:
- *   - For every node: |height(left) - height(right)| <= 1
- *   - Maintains O(log n) time complexity for insert/delete/search
- */
 public class AVL {
 
-    /**
-     * Inner class to represent a node in AVL Tree
-     */
     private static class Node {
         int key;
         int height;
@@ -28,263 +14,230 @@ private static class Node {
 
         Node(int key) {
             this.key = key;
-            this.height = 1; // New node starts as a leaf node with height = 1
+            left = right = null;
+            this.height = 1;
         }
     }
 
-    // Root node of the AVL Tree
     private Node root;
 
-    // Constructor
     public AVL() {
         root = null;
     }
 
-    /* ======================== PUBLIC METHODS ======================== */
-
-    /** Insert a key into the AVL Tree */
     public void insert(int key) {
         root = insertRecursive(root, key);
     }
 
-    /** Delete a key from the AVL Tree */
     public void delete(int key) {
         root = deleteRecursive(root, key);
     }
 
-    /** Search a key in the AVL Tree */
     public boolean search(int key) {
         return searchRecursive(root, key);
     }
 
-    /** Return the smallest key in the AVL Tree */
     public int findMin() {
-        if (root == null) throw new NoSuchElementException("AVL Tree is empty");
+        if (root == null) {
+            throw new NoSuchElementException("AVL Tree is empty");
+        }
         return findMinNode(root).key;
     }
 
-    /** Return the largest key in the AVL Tree */
     public int findMax() {
-        if (root == null) throw new NoSuchElementException("AVL Tree is empty");
+        if (root == null) {
+            throw new NoSuchElementException("AVL Tree is empty");
+        }
         Node cur = root;
-        while (cur.right != null) cur = cur.right;
+        while (cur.right != null) {
+            cur = cur.right;
+        }
         return cur.key;
     }
 
-    /** Print nodes in Inorder (sorted order) */
     public void printInorder() {
         System.out.print("Inorder: ");
         printInorderRecursive(root);
         System.out.println();
     }
 
-    /** Print nodes in Preorder (Root → Left → Right) */
     public void printPreorder() {
         System.out.print("Preorder: ");
         printPreorderRecursive(root);
         System.out.println();
     }
 
-    /** Print nodes in Postorder (Left → Right → Root) */
     public void printPostorder() {
         System.out.print("Postorder: ");
         printPostorderRecursive(root);
         System.out.println();
     }
 
-    /** Return Inorder list (useful for testing) */
     public List<Integer> inorderList() {
         List<Integer> res = new ArrayList<>();
         inorderToList(root, res);
         return res;
     }
 
-    /** Return Preorder list (useful for testing) */
     public List<Integer> preorderList() {
         List<Integer> res = new ArrayList<>();
         preorderToList(root, res);
         return res;
     }
 
-    /** Return Postorder list (useful for testing) */
     public List<Integer> postorderList() {
         List<Integer> res = new ArrayList<>();
         postorderToList(root, res);
         return res;
     }
 
-    /**
-     * Recursive insert:
-     * 1. Insert key like a normal BST
-     * 2. Update height of current node
-     * 3. Balance the node if it became unbalanced
-     */
     private Node insertRecursive(Node node, int key) {
-        // Step 1: Perform standard BST insert
         if (node == null) {
             return new Node(key);
         }
 
-        if (key < node.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
-            return node; // Duplicates not allowed
+        } else {
+            return node;
+        }
 
-        // Step 2: Update height of ancestor node
         updateHeight(node);
-
-        // Step 3: Balance the node and return new root
         return balanceNode(node);
     }
 
-    /**
-     * Recursive delete:
-     * 1. Perform normal BST delete
-     * 2. Update height of current node
-     * 3. Balance it if necessary
-     */
     private Node deleteRecursive(Node node, int key) {
-        if (node == null) return null;
+        if (node == null) {
+            return null;
+        }
 
-        // Step 1: Perform BST delete
-        if (key < node.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 {
-            // Node found
+        } else {
             if (node.left == null || node.right == null) {
-                Node temp = (node.left != null) ? node.left : node.right;
+                Node temp = null;
+                if (node.left != null) {
+                    temp = node.left;
+                } else {
+                    temp = node.right;
+                }
 
-                // No child case
                 if (temp == null) {
                     node = null;
                 } else {
                     node = temp;
                 }
             } else {
-                // Node with two children → get inorder successor
                 Node successor = findMinNode(node.right);
                 node.key = successor.key;
                 node.right = deleteRecursive(node.right, successor.key);
             }
         }
 
-        // If tree had only one node
-        if (node == null) return null;
+        if (node == null) {
+            return null;
+        }
 
-        // Step 2: Update height
         updateHeight(node);
-
-        // Step 3: Rebalance node
         return balanceNode(node);
     }
 
-    /** Recursive search like normal BST */
     private boolean searchRecursive(Node node, int key) {
-        if (node == null) return false;
-        if (key == node.key) return true;
-        return key < node.key ? searchRecursive(node.left, key) : searchRecursive(node.right, key);
+        if (node == null) {
+            return false;
+        }
+        if (key == node.key) {
+            return true;
+        }
+        if (key < node.key) {
+            return searchRecursive(node.left, key);
+        } else {
+            return searchRecursive(node.right, key);
+        }
     }
 
-    /** Find node with minimum key */
     private Node findMinNode(Node node) {
         Node cur = node;
-        while (cur.left != null) cur = cur.left;
+        while (cur.left != null) {
+            cur = cur.left;
+        }
         return cur;
     }
 
-    /* ======================== ROTATIONS & BALANCING ======================== */
-
-    /** Right rotation (used in LL or LR imbalance) */
     private Node rightRotate(Node y) {
         Node x = y.left;
         Node T2 = x.right;
 
-        // Perform rotation
         x.right = y;
         y.left = T2;
 
-        // Update heights
         updateHeight(y);
         updateHeight(x);
 
-        return x; // New root
+        return x;
     }
 
-    /** Left rotation (used in RR or RL imbalance) */
     private Node leftRotate(Node x) {
         Node y = x.right;
         Node T2 = y.left;
 
-        // Perform rotation
         y.left = x;
         x.right = T2;
 
-        // Update heights
         updateHeight(x);
         updateHeight(y);
 
-        return y; // New root
+        return y;
     }
 
-    /**
-     * Balances a node by checking its balance factor:
-     *
-     *  - If > 1 → left heavy
-     *  - If < -1 → right heavy
-     *
-     * Depending on the case, we do:
-     *  - LL → Right Rotate
-     *  - RR → Left Rotate
-     *  - LR → Left Rotate child + Right Rotate
-     *  - RL → Right Rotate child + Left Rotate
-     */
     private Node balanceNode(Node node) {
         int balance = getBalance(node);
 
-        // Case 1: Left Left (LL)
-        if (balance > 1 && getBalance(node.left) >= 0) return rightRotate(node);
+        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);
             return rightRotate(node);
         }
 
-        // Case 3: Right Right (RR)
-        if (balance < -1 && getBalance(node.right) <= 0) return leftRotate(node);
+        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);
             return leftRotate(node);
         }
 
-        return node; // Already balanced
+        return node;
     }
 
-    /* ======================== HELPER FUNCTIONS ======================== */
-
-    /** Returns height of a node */
     private int height(Node node) {
-        return node == null ? 0 : node.height;
+        if (node == null) {
+            return 0;
+        } else {
+            return node.height;
+        }
     }
 
-    /** Updates height of a node based on its children */
     private void updateHeight(Node node) {
         node.height = 1 + Math.max(height(node.left), height(node.right));
     }
 
-    /** Calculates balance factor = height(left) - height(right) */
     private int getBalance(Node node) {
-        return node == null ? 0 : height(node.left) - height(node.right);
+        if (node == null) {
+            return 0;
+        } else {
+            return height(node.left) - height(node.right);
+        }
     }
 
-    /* ======================== TRAVERSALS ======================== */
-
     private void printInorderRecursive(Node node) {
         if (node == null) {
             return;
@@ -338,41 +291,4 @@ private void postorderToList(Node node, List<Integer> out) {
         postorderToList(node.right, out);
         out.add(node.key);
     }
-
-    public static void main(String[] args) {
-        AVL avl = new AVL();
-
-        int[] values = {30, 20, 40, 10, 25, 35, 50, 5, 15, 27, 45, 60};
-
-        // Insert all values one by one
-        for (int v : values) avl.insert(v);
-
-        // Display traversals
-        avl.printInorder(); // should show sorted order
-        avl.printPreorder();
-        avl.printPostorder();
-
-        // Display traversal lists
-        System.out.println("Inorder List: " + avl.inorderList());
-        System.out.println("Preorder List: " + avl.preorderList());
-        System.out.println("Postorder List: " + avl.postorderList());
-
-        // Search examples
-        System.out.println("Search 27: " + avl.search(27)); // true
-        System.out.println("Search 99: " + avl.search(99)); // false
-
-        // Min and Max
-        System.out.println("Min: " + avl.findMin());
-        System.out.println("Max: " + avl.findMax());
-
-        // Delete operations and show tree after each
-        avl.delete(10);
-        System.out.println("After deleting 10: " + avl.inorderList());
-
-        avl.delete(30);
-        System.out.println("After deleting 30: " + avl.inorderList());
-
-        avl.delete(40);
-        System.out.println("After deleting 40: " + avl.inorderList());
-    }
 }