From a85e51e040446c8205ebde086e58053b45a697ed Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 11:01:48 +0530
Subject: [PATCH 1/6] Add AVL Tree module with insert, delete, and balance
 check implementations

---
 .../thealgorithms/tree/AVLtree/AVLDelete.java | 88 +++++++++++++++++
 .../thealgorithms/tree/AVLtree/AVLInsert.java | 99 +++++++++++++++++++
 .../tree/AVLtree/CheckBalance.java            | 30 ++++++
 .../thealgorithms/tree/AVLtree/Rotations.java | 38 +++++++
 4 files changed, 255 insertions(+)
 create mode 100644 src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
 create mode 100644 src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
 create mode 100644 src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
 create mode 100644 src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
new file mode 100644
index 000000000000..c9116e786af6
--- /dev/null
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
@@ -0,0 +1,88 @@
+package com.thealgorithms.tree.AVLtree;
+
+
+
+public class AVLDelete extends AVLInsert {
+
+    Node minValueNode(Node node) {
+        Node current = node;
+        while (current.left != null)
+            current = current.left;
+        return current;
+    }
+
+    Node deleteNode(Node root, int key) {
+        if (root == null)
+            return root;
+
+        if (key < root.key)
+            root.left = deleteNode(root.left, key);
+        else if (key > root.key)
+            root.right = deleteNode(root.right, key);
+        else {
+            if ((root.left == null) || (root.right == null)) {
+                Node temp = null;
+                if (root.left != null)
+                    temp = root.left;
+                else
+                    temp = root.right;
+
+                if (temp == null) {
+                    root = null;
+                } else {
+                    root = temp;
+                }
+            } else {
+                Node temp = minValueNode(root.right);
+                root.key = temp.key;
+                root.right = deleteNode(root.right, temp.key);
+            }
+        }
+
+        if (root == null)
+            return root;
+
+        root.height = Math.max(height(root.left), height(root.right)) + 1;
+        int balance = getBalance(root);
+
+        if (balance > 1 && getBalance(root.left) >= 0)
+            return rightRotate(root);
+
+        if (balance > 1 && getBalance(root.left) < 0) {
+            root.left = leftRotate(root.left);
+            return rightRotate(root);
+        }
+
+        if (balance < -1 && getBalance(root.right) <= 0)
+            return leftRotate(root);
+
+        if (balance < -1 && getBalance(root.right) > 0) {
+            root.right = rightRotate(root.right);
+            return leftRotate(root);
+        }
+
+        return root;
+    }
+
+    public static void main(String[] args) {
+        AVLDelete tree = new AVLDelete();
+        tree.root = tree.insert(tree.root, 9);
+        tree.root = tree.insert(tree.root, 5);
+        tree.root = tree.insert(tree.root, 10);
+        tree.root = tree.insert(tree.root, 0);
+        tree.root = tree.insert(tree.root, 6);
+        tree.root = tree.insert(tree.root, 11);
+        tree.root = tree.insert(tree.root, -1);
+        tree.root = tree.insert(tree.root, 1);
+        tree.root = tree.insert(tree.root, 2);
+
+        System.out.println("Preorder before deletion:");
+        tree.preOrder(tree.root);
+
+        tree.root = tree.deleteNode(tree.root, 10);
+
+        System.out.println("\nPreorder after deletion:");
+        tree.preOrder(tree.root);
+    }
+}
+
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
new file mode 100644
index 000000000000..790084d29c63
--- /dev/null
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
@@ -0,0 +1,99 @@
+package com.thealgorithms.tree.AVLtree;
+
+class Node {
+    int key, height;
+    Node left, right;
+
+    Node(int d) {
+        key = d;
+        height = 1;
+    }
+}
+
+public class AVLInsert {
+
+    Node root;
+
+    int height(Node n) {
+        return n == null ? 0 : n.height;
+    }
+
+    int getBalance(Node n) {
+        return n == null ? 0 : height(n.left) - height(n.right);
+    }
+
+    Node rightRotate(Node y) {
+        Node x = y.left;
+        Node T2 = x.right;
+        x.right = y;
+        y.left = T2;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        return x;
+    }
+
+    Node leftRotate(Node x) {
+        Node y = x.right;
+        Node T2 = y.left;
+        y.left = x;
+        x.right = T2;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        return y;
+    }
+
+    Node insert(Node node, int key) {
+        if (node == null)
+            return new Node(key);
+
+        if (key < node.key)
+            node.left = insert(node.left, key);
+        else if (key > node.key)
+            node.right = insert(node.right, key);
+        else
+            return node;
+
+        node.height = 1 + Math.max(height(node.left), height(node.right));
+        int balance = getBalance(node);
+
+        if (balance > 1 && key < node.left.key)
+            return rightRotate(node);
+
+        if (balance < -1 && key > node.right.key)
+            return leftRotate(node);
+
+        if (balance > 1 && key > node.left.key) {
+            node.left = leftRotate(node.left);
+            return rightRotate(node);
+        }
+
+        if (balance < -1 && key < node.right.key) {
+            node.right = rightRotate(node.right);
+            return leftRotate(node);
+        }
+
+        return node;
+    }
+
+    void preOrder(Node node) {
+        if (node != null) {
+            System.out.print(node.key + " ");
+            preOrder(node.left);
+            preOrder(node.right);
+        }
+    }
+
+    public static void main(String[] args) {
+        AVLInsert tree = new AVLInsert();
+
+        tree.root = tree.insert(tree.root, 10);
+        tree.root = tree.insert(tree.root, 20);
+        tree.root = tree.insert(tree.root, 30);
+        tree.root = tree.insert(tree.root, 40);
+        tree.root = tree.insert(tree.root, 50);
+        tree.root = tree.insert(tree.root, 25);
+
+        System.out.println("Preorder traversal of AVL tree:");
+        tree.preOrder(tree.root);
+    }
+}
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
new file mode 100644
index 000000000000..b553fabb934f
--- /dev/null
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
@@ -0,0 +1,30 @@
+package com.thealgorithms.tree.AVLtree;
+
+
+
+public class CheckBalance extends AVLInsert {
+
+    boolean isBalanced(Node node) {
+        if (node == null)
+            return true;
+
+        int balance = getBalance(node);
+        if (Math.abs(balance) > 1)
+            return false;
+
+        return isBalanced(node.left) && isBalanced(node.right);
+    }
+
+    public static void main(String[] args) {
+        CheckBalance tree = new CheckBalance();
+        tree.root = tree.insert(tree.root, 10);
+        tree.root = tree.insert(tree.root, 20);
+        tree.root = tree.insert(tree.root, 30);
+
+        System.out.println("Is AVL Tree balanced? " + tree.isBalanced(tree.root));
+
+        tree.root.left.left = new Node(5);  // Manually unbalance it
+        System.out.println("Is AVL Tree balanced after modification? " + tree.isBalanced(tree.root));
+    }
+}
+
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
new file mode 100644
index 000000000000..beecb7f81d69
--- /dev/null
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
@@ -0,0 +1,38 @@
+package com.thealgorithms.tree.AVLtree;
+
+
+
+public class Rotations extends AVLInsert {
+
+    public Node rightRotate(Node y) {
+        Node x = y.left;
+        Node T2 = x.right;
+        x.right = y;
+        y.left = T2;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        return x;
+    }
+
+    public Node leftRotate(Node x) {
+        Node y = x.right;
+        Node T2 = y.left;
+        y.left = x;
+        x.right = T2;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        return y;
+    }
+
+    public static void main(String[] args) {
+        Rotations r = new Rotations();
+        Node root = new Node(30);
+        root.left = new Node(20);
+        root.left.left = new Node(10);
+
+        System.out.println("Performing right rotation on 30...");
+        root = r.rightRotate(root);
+        System.out.println("New root after rotation: " + root.key);
+    }
+}
+

From da84c5fd022dec6dd6507796d0bd1a4930739216 Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 11:16:03 +0530
Subject: [PATCH 2/6] style: fix Checkstyle violations in AVLInsert.java

---
 .../thealgorithms/tree/AVLtree/AVLInsert.java | 64 +++++++++++++------
 1 file changed, 46 insertions(+), 18 deletions(-)

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
index 790084d29c63..2b3c66eb9e18 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
@@ -1,8 +1,10 @@
 package com.thealgorithms.tree.AVLtree;
 
 class Node {
-    int key, height;
-    Node left, right;
+    int key;
+    int height;
+    Node left;
+    Node right;
 
     Node(int d) {
         key = d;
@@ -14,59 +16,85 @@ public class AVLInsert {
 
     Node root;
 
-    int height(Node n) {
-        return n == null ? 0 : n.height;
+    int height(Node node) {
+        if (node == null) {
+            return 0;
+        }
+        return node.height;
     }
 
-    int getBalance(Node n) {
-        return n == null ? 0 : height(n.left) - height(n.right);
+    int getBalance(Node node) {
+        if (node == null) {
+            return 0;
+        }
+        return height(node.left) - height(node.right);
     }
 
     Node rightRotate(Node y) {
         Node x = y.left;
-        Node T2 = x.right;
+        Node t2 = x.right;
+
+        // Perform rotation
         x.right = y;
-        y.left = T2;
+        y.left = t2;
+
+        // Update heights
         y.height = Math.max(height(y.left), height(y.right)) + 1;
         x.height = Math.max(height(x.left), height(x.right)) + 1;
+
+        // Return new root
         return x;
     }
 
     Node leftRotate(Node x) {
         Node y = x.right;
-        Node T2 = y.left;
+        Node t2 = y.left;
+
+        // Perform rotation
         y.left = x;
-        x.right = T2;
+        x.right = t2;
+
+        // Update heights
         x.height = Math.max(height(x.left), height(x.right)) + 1;
         y.height = Math.max(height(y.left), height(y.right)) + 1;
+
+        // Return new root
         return y;
     }
 
     Node insert(Node node, int key) {
-        if (node == null)
+        if (node == null) {
             return new Node(key);
+        }
 
-        if (key < node.key)
+        if (key < node.key) {
             node.left = insert(node.left, key);
-        else if (key > node.key)
+        } else if (key > node.key) {
             node.right = insert(node.right, key);
-        else
-            return node;
+        } else {
+            return node; // Duplicate keys not allowed
+        }
 
         node.height = 1 + Math.max(height(node.left), height(node.right));
         int balance = getBalance(node);
 
-        if (balance > 1 && key < node.left.key)
+        // Left Left Case
+        if (balance > 1 && key < node.left.key) {
             return rightRotate(node);
+        }
 
-        if (balance < -1 && key > node.right.key)
+        // Right Right Case
+        if (balance < -1 && key > node.right.key) {
             return leftRotate(node);
+        }
 
+        // Left Right Case
         if (balance > 1 && key > node.left.key) {
             node.left = leftRotate(node.left);
             return rightRotate(node);
         }
 
+        // Right Left Case
         if (balance < -1 && key < node.right.key) {
             node.right = rightRotate(node.right);
             return leftRotate(node);
@@ -93,7 +121,7 @@ public static void main(String[] args) {
         tree.root = tree.insert(tree.root, 50);
         tree.root = tree.insert(tree.root, 25);
 
-        System.out.println("Preorder traversal of AVL tree:");
+        System.out.println("Preorder traversal of constructed tree is:");
         tree.preOrder(tree.root);
     }
 }

From 0ad926b101acad1dc32541ffd5c3d7f9fee98713 Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 11:20:31 +0530
Subject: [PATCH 3/6] style: fix Checkstyle violations in AVLTree package

---
 .../thealgorithms/tree/AVLtree/AVLDelete.java | 39 ++++++++++---------
 .../tree/AVLtree/CheckBalance.java            | 12 ++++--
 .../thealgorithms/tree/AVLtree/Rotations.java | 38 ++++--------------
 3 files changed, 36 insertions(+), 53 deletions(-)

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
index c9116e786af6..f1069ff9ea54 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
@@ -1,32 +1,27 @@
 package com.thealgorithms.tree.AVLtree;
 
-
-
 public class AVLDelete extends AVLInsert {
 
     Node minValueNode(Node node) {
         Node current = node;
-        while (current.left != null)
+        while (current.left != null) {
             current = current.left;
+        }
         return current;
     }
 
     Node deleteNode(Node root, int key) {
-        if (root == null)
+        if (root == null) {
             return root;
+        }
 
-        if (key < root.key)
+        if (key < root.key) {
             root.left = deleteNode(root.left, key);
-        else if (key > root.key)
+        } else if (key > root.key) {
             root.right = deleteNode(root.right, key);
-        else {
+        } else {
             if ((root.left == null) || (root.right == null)) {
-                Node temp = null;
-                if (root.left != null)
-                    temp = root.left;
-                else
-                    temp = root.right;
-
+                Node temp = (root.left != null) ? root.left : root.right;
                 if (temp == null) {
                     root = null;
                 } else {
@@ -39,23 +34,30 @@ else if (key > root.key)
             }
         }
 
-        if (root == null)
+        if (root == null) {
             return root;
+        }
 
         root.height = Math.max(height(root.left), height(root.right)) + 1;
         int balance = getBalance(root);
 
-        if (balance > 1 && getBalance(root.left) >= 0)
+        // Left Left Case
+        if (balance > 1 && getBalance(root.left) >= 0) {
             return rightRotate(root);
+        }
 
+        // Left Right Case
         if (balance > 1 && getBalance(root.left) < 0) {
             root.left = leftRotate(root.left);
             return rightRotate(root);
         }
 
-        if (balance < -1 && getBalance(root.right) <= 0)
+        // Right Right Case
+        if (balance < -1 && getBalance(root.right) <= 0) {
             return leftRotate(root);
+        }
 
+        // Right Left Case
         if (balance < -1 && getBalance(root.right) > 0) {
             root.right = rightRotate(root.right);
             return leftRotate(root);
@@ -76,13 +78,12 @@ public static void main(String[] args) {
         tree.root = tree.insert(tree.root, 1);
         tree.root = tree.insert(tree.root, 2);
 
-        System.out.println("Preorder before deletion:");
+        System.out.println("Preorder traversal before deletion:");
         tree.preOrder(tree.root);
 
         tree.root = tree.deleteNode(tree.root, 10);
 
-        System.out.println("\nPreorder after deletion:");
+        System.out.println("\nPreorder traversal after deletion:");
         tree.preOrder(tree.root);
     }
 }
-
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
index b553fabb934f..008040f53e78 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
@@ -2,15 +2,19 @@
 
 
 
+;
+
 public class CheckBalance extends AVLInsert {
 
     boolean isBalanced(Node node) {
-        if (node == null)
+        if (node == null) {
             return true;
+        }
 
         int balance = getBalance(node);
-        if (Math.abs(balance) > 1)
+        if (Math.abs(balance) > 1) {
             return false;
+        }
 
         return isBalanced(node.left) && isBalanced(node.right);
     }
@@ -23,8 +27,8 @@ public static void main(String[] args) {
 
         System.out.println("Is AVL Tree balanced? " + tree.isBalanced(tree.root));
 
-        tree.root.left.left = new Node(5);  // Manually unbalance it
+        // Manually unbalance the tree
+        tree.root.left.left = new Node(5);
         System.out.println("Is AVL Tree balanced after modification? " + tree.isBalanced(tree.root));
     }
 }
-
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
index beecb7f81d69..24a1540855c1 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
@@ -1,38 +1,16 @@
 package com.thealgorithms.tree.AVLtree;
 
-
-
 public class Rotations extends AVLInsert {
 
-    public Node rightRotate(Node y) {
-        Node x = y.left;
-        Node T2 = x.right;
-        x.right = y;
-        y.left = T2;
-        y.height = Math.max(height(y.left), height(y.right)) + 1;
-        x.height = Math.max(height(x.left), height(x.right)) + 1;
-        return x;
-    }
-
-    public Node leftRotate(Node x) {
-        Node y = x.right;
-        Node T2 = y.left;
-        y.left = x;
-        x.right = T2;
-        x.height = Math.max(height(x.left), height(x.right)) + 1;
-        y.height = Math.max(height(y.left), height(y.right)) + 1;
-        return y;
-    }
-
     public static void main(String[] args) {
-        Rotations r = new Rotations();
-        Node root = new Node(30);
-        root.left = new Node(20);
-        root.left.left = new Node(10);
+        Rotations tree = new Rotations();
+        tree.root = tree.insert(tree.root, 30);
+        tree.root = tree.insert(tree.root, 20);
+        tree.root = tree.insert(tree.root, 10);
 
-        System.out.println("Performing right rotation on 30...");
-        root = r.rightRotate(root);
-        System.out.println("New root after rotation: " + root.key);
+        System.out.println("Performing right rotation...");
+        tree.root = tree.rightRotate(tree.root);
+
+        System.out.println("New root after rotation: " + tree.root.key);
     }
 }
-

From 97c0377d90274f388ce68e349de1225a23eb2950 Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 11:22:14 +0530
Subject: [PATCH 4/6] style: fix Checkstyle violations in AVLTree package

---
 .../com/thealgorithms/tree/AVLtree/CheckBalance.java     | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
index 008040f53e78..cfd0af1099ff 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
@@ -1,9 +1,5 @@
 package com.thealgorithms.tree.AVLtree;
 
-
-
-;
-
 public class CheckBalance extends AVLInsert {
 
     boolean isBalanced(Node node) {
@@ -24,10 +20,13 @@ public static void main(String[] args) {
         tree.root = tree.insert(tree.root, 10);
         tree.root = tree.insert(tree.root, 20);
         tree.root = tree.insert(tree.root, 30);
+        tree.root = tree.insert(tree.root, 40);
+        tree.root = tree.insert(tree.root, 50);
+        tree.root = tree.insert(tree.root, 25);
 
         System.out.println("Is AVL Tree balanced? " + tree.isBalanced(tree.root));
 
-        // Manually unbalance the tree
+        // Manually unbalance it
         tree.root.left.left = new Node(5);
         System.out.println("Is AVL Tree balanced after modification? " + tree.isBalanced(tree.root));
     }

From dfe4a28ca33edbc8f4d0854d6dab83d54d9b16f4 Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 11:43:53 +0530
Subject: [PATCH 5/6] Refactor: fix missing height() method and improve AVL
 tree structure

---
 .../thealgorithms/tree/AVLtree/AVLDelete.java | 80 +++++++++++++-----
 .../thealgorithms/tree/AVLtree/AVLInsert.java | 82 +++++--------------
 .../tree/AVLtree/CheckBalance.java            | 18 +---
 .../thealgorithms/tree/AVLtree/Rotations.java | 30 +++++--
 4 files changed, 102 insertions(+), 108 deletions(-)

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
index f1069ff9ea54..59ab8a38ffa5 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java
@@ -1,8 +1,54 @@
 package com.thealgorithms.tree.AVLtree;
 
-public class AVLDelete extends AVLInsert {
+public class AVLDelete {
 
-    Node minValueNode(Node node) {
+    static class Node {
+        int key, height;
+        Node left, right;
+
+        Node(int d) {
+            key = d;
+            height = 1;
+        }
+    }
+
+    private Node root;
+
+    private int height(Node n) {
+        return (n == null) ? 0 : n.height;
+    }
+
+    private int getBalance(Node n) {
+        return (n == null) ? 0 : height(n.left) - height(n.right);
+    }
+
+    private Node rightRotate(Node y) {
+        Node x = y.left;
+        Node T2 = x.right;
+
+        x.right = y;
+        y.left = T2;
+
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+
+        return x;
+    }
+
+    private Node leftRotate(Node x) {
+        Node y = x.right;
+        Node T2 = y.left;
+
+        y.left = x;
+        x.right = T2;
+
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+
+        return y;
+    }
+
+    private Node minValueNode(Node node) {
         Node current = node;
         while (current.left != null) {
             current = current.left;
@@ -10,7 +56,7 @@ Node minValueNode(Node node) {
         return current;
     }
 
-    Node deleteNode(Node root, int key) {
+    public Node deleteNode(Node root, int key) {
         if (root == null) {
             return root;
         }
@@ -20,9 +66,11 @@ Node deleteNode(Node root, int key) {
         } else if (key > root.key) {
             root.right = deleteNode(root.right, key);
         } else {
+            // Node with only one child or no child
             if ((root.left == null) || (root.right == null)) {
                 Node temp = (root.left != null) ? root.left : root.right;
                 if (temp == null) {
+                    temp = root;
                     root = null;
                 } else {
                     root = temp;
@@ -39,6 +87,7 @@ Node deleteNode(Node root, int key) {
         }
 
         root.height = Math.max(height(root.left), height(root.right)) + 1;
+
         int balance = getBalance(root);
 
         // Left Left Case
@@ -66,24 +115,11 @@ Node deleteNode(Node root, int key) {
         return root;
     }
 
-    public static void main(String[] args) {
-        AVLDelete tree = new AVLDelete();
-        tree.root = tree.insert(tree.root, 9);
-        tree.root = tree.insert(tree.root, 5);
-        tree.root = tree.insert(tree.root, 10);
-        tree.root = tree.insert(tree.root, 0);
-        tree.root = tree.insert(tree.root, 6);
-        tree.root = tree.insert(tree.root, 11);
-        tree.root = tree.insert(tree.root, -1);
-        tree.root = tree.insert(tree.root, 1);
-        tree.root = tree.insert(tree.root, 2);
-
-        System.out.println("Preorder traversal before deletion:");
-        tree.preOrder(tree.root);
-
-        tree.root = tree.deleteNode(tree.root, 10);
-
-        System.out.println("\nPreorder traversal after deletion:");
-        tree.preOrder(tree.root);
+    public Node getRoot() {
+        return root;
+    }
+
+    public void setRoot(Node root) {
+        this.root = root;
     }
 }
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
index 2b3c66eb9e18..47da2a09acd6 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/AVLInsert.java
@@ -1,68 +1,54 @@
 package com.thealgorithms.tree.AVLtree;
 
-class Node {
-    int key;
-    int height;
-    Node left;
-    Node right;
-
-    Node(int d) {
-        key = d;
-        height = 1;
-    }
-}
-
 public class AVLInsert {
 
-    Node root;
+    static class Node {
+        int key, height;
+        Node left, right;
 
-    int height(Node node) {
-        if (node == null) {
-            return 0;
+        Node(int key) {
+            this.key = key;
+            height = 1;
         }
-        return node.height;
     }
 
-    int getBalance(Node node) {
-        if (node == null) {
-            return 0;
-        }
-        return height(node.left) - height(node.right);
+    protected Node root;
+
+    protected int height(Node node) {
+        return (node == null) ? 0 : node.height;
+    }
+
+    protected int getBalance(Node node) {
+        return (node == null) ? 0 : height(node.left) - height(node.right);
     }
 
-    Node rightRotate(Node y) {
+    protected Node rightRotate(Node y) {
         Node x = y.left;
-        Node t2 = x.right;
+        Node T2 = x.right;
 
-        // Perform rotation
         x.right = y;
-        y.left = t2;
+        y.left = T2;
 
-        // Update heights
         y.height = Math.max(height(y.left), height(y.right)) + 1;
         x.height = Math.max(height(x.left), height(x.right)) + 1;
 
-        // Return new root
         return x;
     }
 
-    Node leftRotate(Node x) {
+    protected Node leftRotate(Node x) {
         Node y = x.right;
-        Node t2 = y.left;
+        Node T2 = y.left;
 
-        // Perform rotation
         y.left = x;
-        x.right = t2;
+        x.right = T2;
 
-        // Update heights
         x.height = Math.max(height(x.left), height(x.right)) + 1;
         y.height = Math.max(height(y.left), height(y.right)) + 1;
 
-        // Return new root
         return y;
     }
 
-    Node insert(Node node, int key) {
+    public Node insert(Node node, int key) {
         if (node == null) {
             return new Node(key);
         }
@@ -78,23 +64,19 @@ Node insert(Node node, int key) {
         node.height = 1 + Math.max(height(node.left), height(node.right));
         int balance = getBalance(node);
 
-        // Left Left Case
         if (balance > 1 && key < node.left.key) {
             return rightRotate(node);
         }
 
-        // Right Right Case
         if (balance < -1 && key > node.right.key) {
             return leftRotate(node);
         }
 
-        // Left Right Case
         if (balance > 1 && key > node.left.key) {
             node.left = leftRotate(node.left);
             return rightRotate(node);
         }
 
-        // Right Left Case
         if (balance < -1 && key < node.right.key) {
             node.right = rightRotate(node.right);
             return leftRotate(node);
@@ -102,26 +84,4 @@ Node insert(Node node, int key) {
 
         return node;
     }
-
-    void preOrder(Node node) {
-        if (node != null) {
-            System.out.print(node.key + " ");
-            preOrder(node.left);
-            preOrder(node.right);
-        }
-    }
-
-    public static void main(String[] args) {
-        AVLInsert tree = new AVLInsert();
-
-        tree.root = tree.insert(tree.root, 10);
-        tree.root = tree.insert(tree.root, 20);
-        tree.root = tree.insert(tree.root, 30);
-        tree.root = tree.insert(tree.root, 40);
-        tree.root = tree.insert(tree.root, 50);
-        tree.root = tree.insert(tree.root, 25);
-
-        System.out.println("Preorder traversal of constructed tree is:");
-        tree.preOrder(tree.root);
-    }
 }
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
index cfd0af1099ff..24811c7a616d 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
@@ -2,7 +2,7 @@
 
 public class CheckBalance extends AVLInsert {
 
-    boolean isBalanced(Node node) {
+    public boolean isBalanced(Node node) {
         if (node == null) {
             return true;
         }
@@ -14,20 +14,4 @@ boolean isBalanced(Node node) {
 
         return isBalanced(node.left) && isBalanced(node.right);
     }
-
-    public static void main(String[] args) {
-        CheckBalance tree = new CheckBalance();
-        tree.root = tree.insert(tree.root, 10);
-        tree.root = tree.insert(tree.root, 20);
-        tree.root = tree.insert(tree.root, 30);
-        tree.root = tree.insert(tree.root, 40);
-        tree.root = tree.insert(tree.root, 50);
-        tree.root = tree.insert(tree.root, 25);
-
-        System.out.println("Is AVL Tree balanced? " + tree.isBalanced(tree.root));
-
-        // Manually unbalance it
-        tree.root.left.left = new Node(5);
-        System.out.println("Is AVL Tree balanced after modification? " + tree.isBalanced(tree.root));
-    }
 }
diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
index 24a1540855c1..76b438cddf75 100644
--- a/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
+++ b/src/test/java/com/thealgorithms/tree/AVLtree/Rotations.java
@@ -2,15 +2,29 @@
 
 public class Rotations extends AVLInsert {
 
-    public static void main(String[] args) {
-        Rotations tree = new Rotations();
-        tree.root = tree.insert(tree.root, 30);
-        tree.root = tree.insert(tree.root, 20);
-        tree.root = tree.insert(tree.root, 10);
+    public Node rightRotate(Node y) {
+        Node x = y.left;
+        Node T2 = x.right;
 
-        System.out.println("Performing right rotation...");
-        tree.root = tree.rightRotate(tree.root);
+        x.right = y;
+        y.left = T2;
 
-        System.out.println("New root after rotation: " + tree.root.key);
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+
+        return x;
+    }
+
+    public Node leftRotate(Node x) {
+        Node y = x.right;
+        Node T2 = y.left;
+
+        y.left = x;
+        x.right = T2;
+
+        x.height = Math.max(height(x.left), height(x.right)) + 1;
+        y.height = Math.max(height(y.left), height(y.right)) + 1;
+
+        return y;
     }
 }

From 1fcd71330fef6b83f3de440ea870cacc2af6c1f1 Mon Sep 17 00:00:00 2001
From: darshan totagi <darshantotagi7975@gmail.com>
Date: Tue, 28 Oct 2025 12:24:36 +0530
Subject: [PATCH 6/6] removing of checkbalance.java

---
 .../tree/AVLtree/CheckBalance.java              | 17 -----------------
 1 file changed, 17 deletions(-)
 delete mode 100644 src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java

diff --git a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java b/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
deleted file mode 100644
index 24811c7a616d..000000000000
--- a/src/test/java/com/thealgorithms/tree/AVLtree/CheckBalance.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.thealgorithms.tree.AVLtree;
-
-public class CheckBalance extends AVLInsert {
-
-    public boolean isBalanced(Node node) {
-        if (node == null) {
-            return true;
-        }
-
-        int balance = getBalance(node);
-        if (Math.abs(balance) > 1) {
-            return false;
-        }
-
-        return isBalanced(node.left) && isBalanced(node.right);
-    }
-}