Merge branch 'master' into generic_heap_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/hashmap/hashing/GenericHashMapUsingArray.java

@@ -2,67 +2,112 @@
 
 import java.util.LinkedList;
 
-// implementation of generic hashmaps using array of Linked Lists
-
+/**
+ * A generic implementation of a hash map using an array of linked lists for collision resolution.
+ * This class provides a way to store key-value pairs efficiently, allowing for average-case
+ * constant time complexity for insertion, deletion, and retrieval operations.
+ *
+ * <p>
+ * The hash map uses separate chaining for collision resolution. Each bucket in the hash map is a
+ * linked list that stores nodes containing key-value pairs. When a collision occurs (i.e., when
+ * two keys hash to the same index), the new key-value pair is simply added to the corresponding
+ * linked list.
+ * </p>
+ *
+ * <p>
+ * The hash map automatically resizes itself when the load factor exceeds 0.75. The load factor is
+ * defined as the ratio of the number of entries to the number of buckets. When resizing occurs,
+ * all existing entries are rehashed and inserted into the new buckets.
+ * </p>
+ *
+ * @param <K> the type of keys maintained by this hash map
+ * @param <V> the type of mapped values
+ */
 public class GenericHashMapUsingArray<K, V> {
 
-    private int size; // n (total number of key-value pairs)
-    private LinkedList<Node>[] buckets; // N = buckets.length
-    private float lf = 0.75f;
+    private int size; // Total number of key-value pairs
+    private LinkedList<Node>[] buckets; // Array of linked lists (buckets) for storing entries
 
+    /**
+     * Constructs a new empty hash map with an initial capacity of 16.
+     */
     public GenericHashMapUsingArray() {
         initBuckets(16);
         size = 0;
     }
 
-    // load factor = 0.75 means if we need to add 100 items and we have added
-    // 75, then adding 76th item it will double the size, copy all elements
-    // & then add 76th item.
-
+    /**
+     * Initializes the buckets for the hash map with the specified number of buckets.
+     *
+     * @param n the number of buckets to initialize
+     */
     private void initBuckets(int n) {
         buckets = new LinkedList[n];
         for (int i = 0; i < buckets.length; i++) {
             buckets[i] = new LinkedList<>();
         }
     }
 
+    /**
+     * Associates the specified value with the specified key in this map.
+     * If the map previously contained a mapping for the key, the old value is replaced.
+     *
+     * @param key the key with which the specified value is to be associated
+     * @param value the value to be associated with the specified key
+     */
     public void put(K key, V value) {
         int bucketIndex = hashFunction(key);
         LinkedList<Node> nodes = buckets[bucketIndex];
-        for (Node node : nodes) { // if key present => update
+        // Update existing key's value if present
+        for (Node node : nodes) {
             if (node.key.equals(key)) {
                 node.value = value;
                 return;
             }
         }
 
-        // key is not present => insert
+        // Insert new key-value pair
         nodes.add(new Node(key, value));
         size++;
 
-        if ((float) size / buckets.length > lf) {
+        // Check if rehashing is needed
+        // Load factor threshold for resizing
+        float loadFactorThreshold = 0.75f;
+        if ((float) size / buckets.length > loadFactorThreshold) {
             reHash();
         }
     }
 
-    // tells which bucket to go to
+    /**
+     * Returns the index of the bucket in which the key would be stored.
+     *
+     * @param key the key whose bucket index is to be computed
+     * @return the bucket index
+     */
     private int hashFunction(K key) {
         return Math.floorMod(key.hashCode(), buckets.length);
     }
 
+    /**
+     * Rehashes the map by doubling the number of buckets and re-inserting all entries.
+     */
     private void reHash() {
-        System.out.println("Rehashing!");
-        LinkedList<Node>[] old = buckets;
-        initBuckets(old.length * 2);
+        LinkedList<Node>[] oldBuckets = buckets;
+        initBuckets(oldBuckets.length * 2);
         this.size = 0;
 
-        for (LinkedList<Node> nodes : old) {
+        for (LinkedList<Node> nodes : oldBuckets) {
             for (Node node : nodes) {
                 put(node.key, node.value);
             }
         }
     }
 
+    /**
+     * Removes the mapping for the specified key from this map if present.
+     *
+     * @param key the key whose mapping is to be removed from the map
+     */
     public void remove(K key) {
         int bucketIndex = hashFunction(key);
         LinkedList<Node> nodes = buckets[bucketIndex];
@@ -74,14 +119,28 @@ public void remove(K key) {
                 break;
             }
         }
-        nodes.remove(target);
-        size--;
+
+        if (target != null) {
+            nodes.remove(target);
+            size--;
+        }
     }
 
+    /**
+     * Returns the number of key-value pairs in this map.
+     *
+     * @return the number of key-value pairs
+     */
     public int size() {
         return this.size;
     }
 
+    /**
+     * Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
+     *
+     * @param key the key whose associated value is to be returned
+     * @return the value associated with the specified key, or null if no mapping exists
+     */
     public V get(K key) {
         int bucketIndex = hashFunction(key);
         LinkedList<Node> nodes = buckets[bucketIndex];
@@ -96,7 +155,6 @@ public V get(K key) {
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();
-
         builder.append("{");
         for (LinkedList<Node> nodes : buckets) {
             for (Node node : nodes) {
@@ -106,19 +164,37 @@ public String toString() {
                 builder.append(", ");
             }
         }
+        // Remove trailing comma and space
+        if (builder.length() > 1) {
+            builder.setLength(builder.length() - 2);
+        }
         builder.append("}");
         return builder.toString();
     }
 
+    /**
+     * Returns true if this map contains a mapping for the specified key.
+     *
+     * @param key the key whose presence in this map is to be tested
+     * @return true if this map contains a mapping for the specified key
+     */
     public boolean containsKey(K key) {
         return get(key) != null;
     }
 
+    /**
+     * A private class representing a key-value pair (node) in the hash map.
+     */
     public class Node {
-
         K key;
         V value;
 
+        /**
+         * Constructs a new Node with the specified key and value.
+         *
+         * @param key the key of the key-value pair
+         * @param value the value of the key-value pair
+         */
         public Node(K key, V value) {
             this.key = key;
             this.value = value;