Merge branch 'master' into hash_improve

Author: siriak

DIRECTORY.md

@@ -560,6 +560,7 @@
             * [NonPreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/NonPreemptivePriorityScheduling.java)
             * [PreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java)
             * [ProportionalFairScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/ProportionalFairScheduling.java)
+            * [RandomScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RandomScheduling.java)
             * [RRScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RRScheduling.java)
             * [SelfAdjustingScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/SelfAdjustingScheduling.java)
             * [SJFScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/SJFScheduling.java)
@@ -911,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)
@@ -1192,6 +1194,7 @@
             * [NonPreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/NonPreemptivePrioritySchedulingTest.java)
             * [PreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/PreemptivePrioritySchedulingTest.java)
             * [ProportionalFairSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/ProportionalFairSchedulingTest.java)
+            * [RandomSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RandomSchedulingTest.java)
             * [RRSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RRSchedulingTest.java)
             * [SelfAdjustingSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SelfAdjustingSchedulingTest.java)
             * [SJFSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SJFSchedulingTest.java)

src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java

@@ -1,14 +1,33 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Converts any Octal Number to a Binary Number
+ * This class provides a method to reverse the bits of a 32-bit integer.
+ * Reversing the bits means that the least significant bit (LSB) becomes
+ * the most significant bit (MSB) and vice versa.
+ *
+ * Example:
+ * Input (binary): 00000010100101000001111010011100 (43261596)
+ * Output (binary): 00111001011110000010100101000000 (964176192)
+ *
+ * Time Complexity: O(32) - A fixed number of 32 iterations
+ * Space Complexity: O(1) - No extra space used
+ *
+ * Note:
+ * - If the input is negative, Java handles it using two’s complement representation.
+ * - This function works on 32-bit integers by default.
+ *
  * @author Bama Charan Chhandogi
  */
-
 public final class ReverseBits {
     private ReverseBits() {
     }
 
+    /**
+     * Reverses the bits of a 32-bit integer.
+     *
+     * @param n the integer whose bits are to be reversed
+     * @return the integer obtained by reversing the bits of the input
+     */
     public static int reverseBits(int n) {
         int result = 0;
         int bitCount = 32;

src/main/java/com/thealgorithms/bitmanipulation/SwapAdjacentBits.java

@@ -1,14 +1,45 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Swap every pair of adjacent bits of a given number.
- * @author Lakshyajeet Singh Goyal (https://github.com/DarkMatter-999)
+ * A utility class to swap every pair of adjacent bits in a given integer.
+ * This operation shifts the even-positioned bits to odd positions and vice versa.
+ *
+ * Example:
+ * - Input: 2 (binary: `10`) → Output: 1 (binary: `01`)
+ * - Input: 43 (binary: `101011`) → Output: 23 (binary: `010111`)
+ *
+ * **Explanation of the Algorithm:**
+ * 1. Mask even-positioned bits: Using `0xAAAAAAAA` (binary: `101010...`),
+ *    which selects bits in even positions.
+ * 2. Mask odd-positioned bits: Using `0x55555555` (binary: `010101...`),
+ *    which selects bits in odd positions.
+ * 3. Shift bits:
+ *    - Right-shift even-positioned bits by 1 to move them to odd positions.
+ *    - Left-shift odd-positioned bits by 1 to move them to even positions.
+ * 4. Combine both shifted results using bitwise OR (`|`) to produce the final result.
+ *
+ * Use Case: This algorithm can be useful in applications involving low-level bit manipulation,
+ * such as encoding, data compression, or cryptographic transformations.
+ *
+ * Time Complexity: O(1) (constant time, since operations are bitwise).
+ *
+ * Author: Lakshyajeet Singh Goyal (https://github.com/DarkMatter-999)
  */
-
 public final class SwapAdjacentBits {
     private SwapAdjacentBits() {
     }
 
+    /**
+     * Swaps every pair of adjacent bits of a given integer.
+     * Steps:
+     * 1. Mask the even-positioned bits.
+     * 2. Mask the odd-positioned bits.
+     * 3. Shift the even bits to the right and the odd bits to the left.
+     * 4. Combine the shifted bits.
+     *
+     * @param num the integer whose bits are to be swapped
+     * @return the integer after swapping every pair of adjacent bits
+     */
     public static int swapAdjacentBits(int num) {
         // mask the even bits (0xAAAAAAAA => 10101010...)
         int evenBits = num & 0xAAAAAAAA;

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/main/java/com/thealgorithms/scheduling/RandomScheduling.java

@@ -0,0 +1,45 @@
+package com.thealgorithms.scheduling;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * RandomScheduling is an algorithm that assigns tasks in a random order.
+ * It doesn't consider priority, deadlines, or burst times, making it
+ * inefficient but useful in scenarios where fairness or unpredictability
+ * is required (e.g., load balancing in distributed systems).
+ *
+ * Use Case: Distributed systems where randomness helps avoid task starvation.
+ *
+ * @author Hardvan
+ */
+public final class RandomScheduling {
+
+    private final List<String> tasks;
+    private final Random random;
+
+    /**
+     * Constructs a new RandomScheduling instance.
+     *
+     * @param tasks A collection of task names to be scheduled.
+     * @param random A Random instance for generating random numbers.
+     */
+    public RandomScheduling(Collection<String> tasks, Random random) {
+        this.tasks = new ArrayList<>(tasks);
+        this.random = random;
+    }
+
+    /**
+     * Schedules the tasks randomly and returns the randomized order.
+     *
+     * @return A list representing the tasks in their randomized execution order.
+     */
+    public List<String> schedule() {
+        List<String> shuffledTasks = new ArrayList<>(tasks);
+        Collections.shuffle(shuffledTasks, random);
+        return shuffledTasks;
+    }
+}