Refactor: fix missing height() method and improve AVL tree structure

Author: darshan-totagi

src/test/java/com/thealgorithms/tree/AVLtree/AVLDelete.java

@@ -1,16 +1,62 @@
 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;
         }
         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;
     }
 }

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,50 +64,24 @@ 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);
         }
 
         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);
-    }
 }

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));
-    }
 }

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;
     }
 }