Enhance docs, add tests in AVLTree (TheAlgorithms#6058)

Author: Hardvan

DIRECTORY.md

@@ -912,6 +912,7 @@
  * [StackArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/StackArrayTest.java)
  * [StackOfLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/StackOfLinkedListTest.java)
  * trees
+ * [AVLTreeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/AVLTreeTest.java)
  * [BinaryTreeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java)
  * [BoundaryTraversalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/BoundaryTraversalTest.java)
  * [BSTFromSortedArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/BSTFromSortedArrayTest.java)

src/main/java/com/thealgorithms/datastructures/trees/AVLTree.java

@@ -1,11 +1,19 @@
 package com.thealgorithms.datastructures.trees;
 
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents an AVL Tree, a self-balancing binary search tree.
+ * In an AVL tree, the heights of the two child subtrees of any node
+ * differ by at most one. If they differ by more than one at any time,
+ * rebalancing is performed to restore this property.
+ */
 public class AVLTree {
 
  private Node root;
 
- private class Node {
-
+ private static class Node {
  private int key;
  private int balance;
  private int height;
@@ -17,8 +25,18 @@ private class Node {
  key = k;
  parent = p;
  }
+
+ public Integer getBalance() {
+ return balance;
+ }
  }
 
+ /**
+ * Inserts a new key into the AVL tree.
+ *
+ * @param key the key to be inserted
+ * @return {@code true} if the key was inserted, {@code false} if the key already exists
+ */
  public boolean insert(int key) {
  if (root == null) {
  root = new Node(key, null);
@@ -31,7 +49,6 @@ public boolean insert(int key) {
  }
 
  parent = n;
-
  boolean goLeft = n.key > key;
  n = goLeft ? n.left : n.right;
 
@@ -49,8 +66,32 @@ public boolean insert(int key) {
  return true;
  }
 
+ /**
+ * Deletes a key from the AVL tree.
+ *
+ * @param delKey the key to be deleted
+ */
+ public void delete(int delKey) {
+ if (root == null) {
+ return;
+ }
+
+ // Find the node to be deleted
+ Node node = root;
+ Node child = root;
+ while (child != null) {
+ node = child;
+ child = delKey >= node.key ? node.right : node.left;
+ if (delKey == node.key) {
+ delete(node);
+ return;
+ }
+ }
+ }
+
  private void delete(Node node) {
  if (node.left == null && node.right == null) {
+ // Leaf node
  if (node.parent == null) {
  root = null;
  } else {
@@ -64,6 +105,8 @@ private void delete(Node node) {
  }
  return;
  }
+
+ // Node has one or two children
  Node child;
  if (node.left != null) {
  child = node.left;
@@ -80,26 +123,49 @@ private void delete(Node node) {
  delete(child);
  }
 
- public void delete(int delKey) {
- if (root == null) {
- return;
+ /**
+ * Returns a list of balance factors for each node in the tree.
+ *
+ * @return a list of integers representing the balance factors of the nodes
+ */
+ public List<Integer> returnBalance() {
+ List<Integer> balances = new ArrayList<>();
+ returnBalance(root, balances);
+ return balances;
+ }
+
+ private void returnBalance(Node n, List<Integer> balances) {
+ if (n != null) {
+ returnBalance(n.left, balances);
+ balances.add(n.getBalance());
+ returnBalance(n.right, balances);
  }
- Node node = root;
- Node child = root;
+ }
 
- while (child != null) {
- node = child;
- child = delKey >= node.key ? node.right : node.left;
- if (delKey == node.key) {
- delete(node);
- return;
- }
+ /**
+ * Searches for a key in the AVL tree.
+ *
+ * @param key the key to be searched
+ * @return true if the key is found, false otherwise
+ */
+ public boolean search(int key) {
+ Node result = searchHelper(this.root, key);
+ return result != null;
+ }
+
+ private Node searchHelper(Node root, int key) {
+ if (root == null || root.key == key) {
+ return root;
  }
+
+ if (root.key > key) {
+ return searchHelper(root.left, key);
+ }
+ return searchHelper(root.right, key);
  }
 
  private void rebalance(Node n) {
  setBalance(n);
-
  if (n.balance == -2) {
  if (height(n.left.left) >= height(n.left.right)) {
  n = rotateRight(n);
@@ -143,7 +209,6 @@ private Node rotateLeft(Node a) {
  }
 
  setBalance(a, b);
-
  return b;
  }
 
@@ -169,7 +234,6 @@ private Node rotateRight(Node a) {
  }
 
  setBalance(a, b);
-
  return b;
  }
 
@@ -197,53 +261,9 @@ private void setBalance(Node... nodes) {
  }
  }
 
- public void printBalance() {
- printBalance(root);
- }
-
- private void printBalance(Node n) {
- if (n != null) {
- printBalance(n.left);
- System.out.printf("%s ", n.balance);
- printBalance(n.right);
- }
- }
-
  private void reheight(Node node) {
  if (node != null) {
  node.height = 1 + Math.max(height(node.left), height(node.right));
  }
  }
-
- public boolean search(int key) {
- Node result = searchHelper(this.root, key);
- return result != null;
- }
-
- private Node searchHelper(Node root, int key) {
- // root is null or key is present at root
- if (root == null || root.key == key) {
- return root;
- }
-
- // key is greater than root's key
- if (root.key > key) {
- return searchHelper(root.left, key); // call the function on the node's left child
- }
- // key is less than root's key then
- // call the function on the node's right child as it is greater
- return searchHelper(root.right, key);
- }
-
- public static void main(String[] args) {
- AVLTree tree = new AVLTree();
-
- System.out.println("Inserting values 1 to 10");
- for (int i = 1; i < 10; i++) {
- tree.insert(i);
- }
-
- System.out.print("Printing balance: ");
- tree.printBalance();
- }
 }

src/test/java/com/thealgorithms/datastructures/trees/AVLTreeTest.java

@@ -0,0 +1,101 @@
+package com.thealgorithms.datastructures.trees;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class AVLTreeTest {
+ private AVLTree avlTree;
+
+ @BeforeEach
+ public void setUp() {
+ avlTree = new AVLTree();
+ }
+
+ @Test
+ public void testInsert() {
+ assertTrue(avlTree.insert(10));
+ assertTrue(avlTree.insert(20));
+ assertTrue(avlTree.insert(5));
+ assertFalse(avlTree.insert(10)); // Duplicate
+ }
+
+ @Test
+ public void testSearch() {
+ avlTree.insert(15);
+ avlTree.insert(25);
+ assertTrue(avlTree.search(15));
+ assertFalse(avlTree.search(30)); // Not in the tree
+ }
+
+ @Test
+ public void testDeleteLeafNode() {
+ avlTree.insert(10);
+ avlTree.insert(20);
+ avlTree.insert(30);
+ avlTree.delete(30);
+ assertFalse(avlTree.search(30));
+ }
+
+ @Test
+ public void testDeleteNodeWithOneChild() {
+ avlTree.insert(20);
+ avlTree.insert(10);
+ avlTree.insert(30);
+ avlTree.delete(10);
+ assertFalse(avlTree.search(10));
+ }
+
+ @Test
+ public void testDeleteNodeWithTwoChildren() {
+ avlTree.insert(20);
+ avlTree.insert(10);
+ avlTree.insert(30);
+ avlTree.insert(25);
+ avlTree.delete(20);
+ assertFalse(avlTree.search(20));
+ assertTrue(avlTree.search(30));
+ assertTrue(avlTree.search(25));
+ }
+
+ @Test
+ public void testReturnBalance() {
+ avlTree.insert(10);
+ avlTree.insert(20);
+ avlTree.insert(5);
+ List<Integer> balances = avlTree.returnBalance();
+ assertEquals(3, balances.size()); // There should be 3 nodes
+ assertEquals(0, balances.get(0)); // Balance for node 5
+ assertEquals(0, balances.get(1)); // Balance for node 10
+ assertEquals(0, balances.get(2)); // Balance for node 20
+ }
+
+ @Test
+ public void testInsertAndRebalance() {
+ avlTree.insert(30);
+ avlTree.insert(20);
+ avlTree.insert(10); // This should cause a right rotation
+ assertTrue(avlTree.search(20));
+ assertTrue(avlTree.search(10));
+ assertTrue(avlTree.search(30));
+ }
+
+ @Test
+ public void testComplexInsertionAndDeletion() {
+ avlTree.insert(30);
+ avlTree.insert(20);
+ avlTree.insert(10);
+ avlTree.insert(25);
+ avlTree.insert(5);
+ avlTree.insert(15);
+
+ avlTree.delete(20); // Test deletion
+ assertFalse(avlTree.search(20));
+ assertTrue(avlTree.search(30));
+ assertTrue(avlTree.search(25));
+ }
+}