Add AVL Tree module with insert, delete, and balance check implementations

Author: darshan-totagi

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

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

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

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