Merge branch 'master' into merge_k_sorted_new_algo

Author: Hardvan

DIRECTORY.md

@@ -39,9 +39,11 @@
             * [IsEven](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IsEven.java)
             * [IsPowerTwo](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IsPowerTwo.java)
             * [LowestSetBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/LowestSetBit.java)
+            * [ModuloPowerOfTwo](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ModuloPowerOfTwo.java)
             * [NonRepeatingNumberFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinder.java)
             * [NumberAppearingOddTimes](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumberAppearingOddTimes.java)
             * [NumbersDifferentSigns](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumbersDifferentSigns.java)
+            * [OneBitDifference](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/OneBitDifference.java)
             * [OnesComplement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/OnesComplement.java)
             * [ParityCheck](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ParityCheck.java)
             * [ReverseBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java)
@@ -100,6 +102,7 @@
             * [IntegerToEnglish](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IntegerToEnglish.java)
             * [IntegerToRoman](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IntegerToRoman.java)
             * [IPConverter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IPConverter.java)
+            * [IPv6Converter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IPv6Converter.java)
             * [MorseCodeConverter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/MorseCodeConverter.java)
             * [OctalToBinary](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/OctalToBinary.java)
             * [OctalToDecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java)
@@ -171,9 +174,14 @@
               * [GenericHeap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/GenericHeap.java)
               * [Heap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/Heap.java)
               * [HeapElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/HeapElement.java)
+              * [KthElementFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/KthElementFinder.java)
               * [LeftistHeap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/LeftistHeap.java)
               * [MaxHeap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/MaxHeap.java)
+
               * [MergeKSortedArrays](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/MergeKSortedArrays.java)
+
+              * [MedianFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/MedianFinder.java)
+
               * [MinHeap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/MinHeap.java)
               * [MinPriorityQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java)
             * lists
@@ -731,9 +739,11 @@
             * [IsEvenTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IsEvenTest.java)
             * [IsPowerTwoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IsPowerTwoTest.java)
             * [LowestSetBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/LowestSetBitTest.java)
+            * [ModuloPowerOfTwoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ModuloPowerOfTwoTest.java)
             * [NonRepeatingNumberFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinderTest.java)
             * [NumberAppearingOddTimesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumberAppearingOddTimesTest.java)
             * [NumbersDifferentSignsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumbersDifferentSignsTest.java)
+            * [OneBitDifferenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/OneBitDifferenceTest.java)
             * [OnesComplementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/OnesComplementTest.java)
             * [ParityCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ParityCheckTest.java)
             * [ReverseBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ReverseBitsTest.java)
@@ -785,6 +795,7 @@
             * [IntegerToEnglishTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IntegerToEnglishTest.java)
             * [IntegerToRomanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IntegerToRomanTest.java)
             * [IPConverterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IPConverterTest.java)
+            * [IPv6ConverterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IPv6ConverterTest.java)
             * [MorseCodeConverterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/MorseCodeConverterTest.java)
             * [OctalToBinaryTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToBinaryTest.java)
             * [OctalToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToDecimalTest.java)
@@ -843,8 +854,13 @@
             * heaps
               * [FibonacciHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/FibonacciHeapTest.java)
               * [GenericHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/GenericHeapTest.java)
+              * [KthElementFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/KthElementFinderTest.java)
               * [LeftistHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/LeftistHeapTest.java)
+
               * [MergeKSortedArraysTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/MergeKSortedArraysTest.java)
+
+              * [MedianFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/MedianFinderTest.java)
+
               * [MinPriorityQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/MinPriorityQueueTest.java)
             * lists
               * [CircleLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CircleLinkedListTest.java)
@@ -871,6 +887,7 @@
               * [TokenBucketTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/TokenBucketTest.java)
             * stacks
               * [NodeStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java)
+              * [ReverseStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/ReverseStackTest.java)
               * [StackArrayListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/StackArrayListTest.java)
               * [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)

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

@@ -1,13 +1,27 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Is number power of 2
+ * Utility class for checking if a number is a power of two.
+ * A power of two is a number that can be expressed as 2^n where n is a non-negative integer.
+ * This class provides a method to determine if a given integer is a power of two using bit manipulation.
+ *
  * @author Bama Charan Chhandogi (https://github.com/BamaCharanChhandogi)
  */
-
 public final class IsPowerTwo {
     private IsPowerTwo() {
     }
+
+    /**
+     * Checks if the given integer is a power of two.
+     *
+     * A number is considered a power of two if it is greater than zero and
+     * has exactly one '1' bit in its binary representation. This method
+     * uses the property that for any power of two (n), the expression
+     * (n & (n - 1)) will be zero.
+     *
+     * @param number the integer to check
+     * @return true if the number is a power of two, false otherwise
+     */
     public static boolean isPowerTwo(int number) {
         if (number <= 0) {
             return false;

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

@@ -0,0 +1,28 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides a method to compute the remainder
+ * of a number when divided by a power of two (2^n)
+ * without using division or modulo operations.
+ *
+ * @author Hardvan
+ */
+public final class ModuloPowerOfTwo {
+    private ModuloPowerOfTwo() {
+    }
+
+    /**
+     * Computes the remainder of a given integer when divided by 2^n.
+     *
+     * @param x the input number
+     * @param n the exponent (power of two)
+     * @return the remainder of x divided by 2^n
+     */
+    public static int moduloPowerOfTwo(int x, int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("The exponent must be positive");
+        }
+
+        return x & ((1 << n) - 1);
+    }
+}

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

@@ -1,14 +1,30 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Find Non Repeating Number
+ * A utility class to find the non-repeating number in an array where every other number repeats.
+ * This class contains a method to identify the single unique number using bit manipulation.
+ *
+ * The solution leverages the properties of the XOR operation, which states that:
+ * - x ^ x = 0 for any integer x (a number XORed with itself is zero)
+ * - x ^ 0 = x for any integer x (a number XORed with zero is the number itself)
+ *
+ * Using these properties, we can find the non-repeating number in linear time with constant space.
+ *
+ * Example:
+ * Given the input array [2, 3, 5, 2, 3], the output will be 5 since it does not repeat.
+ *
  * @author Bama Charan Chhandogi (https://github.com/BamaCharanChhandogi)
  */
-
 public final class NonRepeatingNumberFinder {
     private NonRepeatingNumberFinder() {
     }
 
+    /**
+     * Finds the non-repeating number in the given array.
+     *
+     * @param arr an array of integers where every number except one appears twice
+     * @return the integer that appears only once in the array or 0 if the array is empty
+     */
     public static int findNonRepeatingNumber(int[] arr) {
         int result = 0;
         for (int num : arr) {

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

@@ -1,21 +1,41 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Find the Number Appearing Odd Times in an array
+ * This class provides a method to find the element that appears an
+ * odd number of times in an array. All other elements in the array
+ * must appear an even number of times for the logic to work.
+ *
+ * The solution uses the XOR operation, which has the following properties:
+ * - a ^ a = 0 (XOR-ing the same numbers cancels them out)
+ * - a ^ 0 = a
+ * - XOR is commutative and associative.
+ *
+ * Time Complexity: O(n), where n is the size of the array.
+ * Space Complexity: O(1), as no extra space is used.
+ *
+ * Usage Example:
+ * int result = NumberAppearingOddTimes.findOddOccurrence(new int[]{1, 2, 1, 2, 3});
+ * // result will be 3
+ *
  * @author Lakshyajeet Singh Goyal (https://github.com/DarkMatter-999)
  */
 
 public final class NumberAppearingOddTimes {
     private NumberAppearingOddTimes() {
     }
+
+    /**
+     * Finds the element in the array that appears an odd number of times.
+     *
+     * @param arr the input array containing integers, where all elements
+     *            except one appear an even number of times.
+     * @return the integer that appears an odd number of times.
+     */
     public static int findOddOccurrence(int[] arr) {
         int result = 0;
-
-        // XOR all elements in the array
         for (int num : arr) {
             result ^= num;
         }
-
         return result;
     }
 }

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

@@ -1,14 +1,29 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Numbers Different Signs
+ * This class provides a method to determine whether two integers have
+ * different signs. It utilizes the XOR operation on the two numbers:
+ *
+ * - If two numbers have different signs, their most significant bits
+ *   (sign bits) will differ, resulting in a negative XOR result.
+ * - If two numbers have the same sign, the XOR result will be non-negative.
+ *
+ * Time Complexity: O(1) - Constant time operation.
+ * Space Complexity: O(1) - No extra space used.
+ *
  * @author Bama Charan Chhandogi
  */
-
 public final class NumbersDifferentSigns {
     private NumbersDifferentSigns() {
     }
 
+    /**
+     * Determines if two integers have different signs using bitwise XOR.
+     *
+     * @param num1 the first integer
+     * @param num2 the second integer
+     * @return true if the two numbers have different signs, false otherwise
+     */
     public static boolean differentSigns(int num1, int num2) {
         return (num1 ^ num2) < 0;
     }

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

@@ -0,0 +1,32 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides a method to detect if two integers
+ * differ by exactly one bit flip.
+ *
+ * Example:
+ * 1 (0001) and 2 (0010) differ by exactly one bit flip.
+ * 7 (0111) and 3 (0011) differ by exactly one bit flip.
+ *
+ * @author Hardvan
+ */
+public final class OneBitDifference {
+    private OneBitDifference() {
+    }
+
+    /**
+     * Checks if two integers differ by exactly one bit.
+     *
+     * @param x the first integer
+     * @param y the second integer
+     * @return true if x and y differ by exactly one bit, false otherwise
+     */
+    public static boolean differByOneBit(int x, int y) {
+        if (x == y) {
+            return false;
+        }
+
+        int xor = x ^ y;
+        return (xor & (xor - 1)) == 0;
+    }
+}

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

@@ -1,34 +1,68 @@
 package com.thealgorithms.bitmanipulation;
 
-/*
+/**
+ * A utility class for performing single-bit operations on integers.
+ * These operations include flipping, setting, clearing, and getting
+ * individual bits at specified positions.
+ *
+ * Bit positions are zero-indexed (i.e., the least significant bit is at position 0).
+ * These methods leverage bitwise operations for optimal performance.
+ *
+ * Examples:
+ * - `flipBit(3, 1)` flips the bit at index 1 in binary `11` (result: `1`).
+ * - `setBit(4, 0)` sets the bit at index 0 in `100` (result: `101` or 5).
+ * - `clearBit(7, 1)` clears the bit at index 1 in `111` (result: `101` or 5).
+ * - `getBit(6, 0)` checks if the least significant bit is set (result: `0`).
+ *
+ * Time Complexity: O(1) for all operations.
+ *
  * Author: lukasb1b (https://github.com/lukasb1b)
  */
-
 public final class SingleBitOperations {
     private SingleBitOperations() {
     }
+
     /**
-     * Flip the bit at position 'bit' in 'num'
+     * Flips (toggles) the bit at the specified position.
+     *
+     * @param num the input number
+     * @param bit the position of the bit to flip (0-indexed)
+     * @return the new number after flipping the specified bit
      */
     public static int flipBit(final int num, final int bit) {
         return num ^ (1 << bit);
     }
+
     /**
-     * Set the bit at position 'bit' to 1 in the 'num' variable
+     * Sets the bit at the specified position to 1.
+     *
+     * @param num the input number
+     * @param bit the position of the bit to set (0-indexed)
+     * @return the new number after setting the specified bit to 1
      */
     public static int setBit(final int num, final int bit) {
         return num | (1 << bit);
     }
+
     /**
-     * Clears the bit located at 'bit' from 'num'
+     * Clears the bit at the specified position (sets it to 0).
+     *
+     * @param num the input number
+     * @param bit the position of the bit to clear (0-indexed)
+     * @return the new number after clearing the specified bit
      */
     public static int clearBit(final int num, final int bit) {
         return num & ~(1 << bit);
     }
+
     /**
-     * Get the bit located at 'bit' from 'num'
+     * Gets the bit value (0 or 1) at the specified position.
+     *
+     * @param num the input number
+     * @param bit the position of the bit to retrieve (0-indexed)
+     * @return 1 if the bit is set, 0 otherwise
      */
     public static int getBit(final int num, final int bit) {
-        return ((num >> bit) & 1);
+        return (num >> bit) & 1;
     }
 }