Merge branch 'master' into refactor/Mode

alxkm · web-flow · commit eeea2a319997 · 2025-07-15T10:23:52.000+03:00
diff --git a/src/main/java/com/thealgorithms/datastructures/disjointsetunion/DisjointSetUnion.java b/src/main/java/com/thealgorithms/datastructures/disjointsetunion/DisjointSetUnion.java
@@ -1,53 +1,65 @@
 package com.thealgorithms.datastructures.disjointsetunion;
 
 /**
- * Disjoint Set Union or DSU is useful for solving problems related to connected components,
- * cycle detection in graphs, and maintaining relationships in disjoint sets of data.
- * It is commonly employed in graph algorithms and problems.
+ * Disjoint Set Union (DSU), also known as Union-Find, is a data structure that tracks a set of elements
+ * partitioned into disjoint (non-overlapping) subsets. It supports two primary operations efficiently:
  *
- * @see <a href="https://en.wikipedia.org/wiki/Disjoint-set_data_structure">Disjoint Set Union</a>
+ * <ul>
+ *     <li>Find: Determine which subset a particular element belongs to.</li>
+ *     <li>Union: Merge two subsets into a single subset.</li>
+ * </ul>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Disjoint-set_data_structure">Disjoint Set Union (Wikipedia)</a>
  */
 public class DisjointSetUnion<T> {
 
     /**
-     * Creates a new node of DSU with parent initialised as same node
+     * Creates a new disjoint set containing the single specified element.
+     *
+     * @param value the element to be placed in a new singleton set
+     * @return a node representing the new set
      */
-    public Node<T> makeSet(final T x) {
-        return new Node<T>(x);
+    public Node<T> makeSet(final T value) {
+        return new Node<>(value);
     }
 
     /**
-     * Finds and returns the representative (root) element of the set to which a given element belongs.
-     * This operation uses path compression to optimize future findSet operations.
+     * Finds and returns the representative (root) of the set containing the given node.
+     * This method applies path compression to flatten the tree structure for future efficiency.
+     *
+     * @param node the node whose set representative is to be found
+     * @return the representative (root) node of the set
      */
     public Node<T> findSet(Node<T> node) {
-        while (node != node.parent) {
-            node = node.parent;
+        if (node != node.parent) {
+            node.parent = findSet(node.parent);
         }
-        return node;
+        return node.parent;
     }
 
     /**
-     * Unions two sets by merging their representative elements. The merge is performed based on the rank of each set
-     * to ensure efficient merging and path compression to optimize future findSet operations.
+     * Merges the sets containing the two given nodes. Union by rank is used to attach the smaller tree under the larger one.
+     * If both sets have the same rank, one becomes the parent and its rank is incremented.
+     *
+     * @param x a node in the first set
+     * @param y a node in the second set
      */
-    public void unionSets(final Node<T> x, final Node<T> y) {
-        Node<T> nx = findSet(x);
-        Node<T> ny = findSet(y);
+    public void unionSets(Node<T> x, Node<T> y) {
+        Node<T> rootX = findSet(x);
+        Node<T> rootY = findSet(y);
 
-        if (nx == ny) {
-            return; // Both elements already belong to the same set.
+        if (rootX == rootY) {
+            return; // They are already in the same set
         }
         // Merging happens based on rank of node, this is done to avoid long chaining of nodes and reduce time
         // to find root of the component. Idea is to attach small components in big, instead of other way around.
-        if (nx.rank > ny.rank) {
-            ny.parent = nx;
-        } else if (ny.rank > nx.rank) {
-            nx.parent = ny;
+        if (rootX.rank > rootY.rank) {
+            rootY.parent = rootX;
+        } else if (rootY.rank > rootX.rank) {
+            rootX.parent = rootY;
         } else {
-            // Both sets have the same rank; choose one as the parent and increment the rank.
-            ny.parent = nx;
-            nx.rank++;
+            rootY.parent = rootX;
+            rootX.rank++;
         }
     }
 }
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/SubsetSumSpaceOptimized.java b/src/main/java/com/thealgorithms/dynamicprogramming/SubsetSumSpaceOptimized.java
@@ -1,35 +1,39 @@
 package com.thealgorithms.dynamicprogramming;
-/*
-The Sum of Subset problem determines whether a subset of elements from a
-given array sums up to a specific target value.
-*/
+
+/**
+ * Utility class for solving the Subset Sum problem using a space-optimized dynamic programming approach.
+ *
+ * <p>This algorithm determines whether any subset of a given array sums up to a specific target value.</p>
+ *
+ * <p><b>Time Complexity:</b> O(n * sum)</p>
+ * <p><b>Space Complexity:</b> O(sum)</p>
+ */
 public final class SubsetSumSpaceOptimized {
     private SubsetSumSpaceOptimized() {
     }
+
     /**
-     * This method checks whether the subset of an array
-     * contains a given sum or not. This is an space
-     * optimized solution using 1D boolean array
-     * Time Complexity: O(n * sum), Space complexity: O(sum)
+     * Determines whether there exists a subset of the given array that adds up to the specified sum.
+     * This method uses a space-optimized dynamic programming approach with a 1D boolean array.
      *
-     * @param arr An array containing integers
-     * @param sum The target sum of the subset
-     * @return True or False
+     * @param nums The array of non-negative integers
+     * @param targetSum The desired subset sum
+     * @return {@code true} if such a subset exists, {@code false} otherwise
      */
-    public static boolean isSubsetSum(int[] arr, int sum) {
-        int n = arr.length;
-        // Declare the boolean array with size sum + 1
-        boolean[] dp = new boolean[sum + 1];
+    public static boolean isSubsetSum(int[] nums, int targetSum) {
+        if (targetSum < 0) {
+            return false; // Subset sum can't be negative
+        }
 
-        // Initialize the first element as true
-        dp[0] = true;
+        boolean[] dp = new boolean[targetSum + 1];
+        dp[0] = true; // Empty subset always sums to 0
 
-        // Find the subset sum using 1D array
-        for (int i = 0; i < n; i++) {
-            for (int j = sum; j >= arr[i]; j--) {
-                dp[j] = dp[j] || dp[j - arr[i]];
+        for (int number : nums) {
+            for (int j = targetSum; j >= number; j--) {
+                dp[j] = dp[j] || dp[j - number];
             }
         }
-        return dp[sum];
+
+        return dp[targetSum];
     }
 }
diff --git a/src/main/java/com/thealgorithms/matrix/MedianOfMatrix.java b/src/main/java/com/thealgorithms/matrix/MedianOfMatrix.java
@@ -14,19 +14,19 @@ private MedianOfMatrix() {
     }
 
     public static int median(Iterable<List<Integer>> matrix) {
-        // Flatten the matrix into a 1D list
-        List<Integer> linear = new ArrayList<>();
+        List<Integer> flattened = new ArrayList<>();
+
         for (List<Integer> row : matrix) {
-            linear.addAll(row);
+            if (row != null) {
+                flattened.addAll(row);
+            }
         }
 
-        // Sort the 1D list
-        Collections.sort(linear);
-
-        // Calculate the middle index
-        int mid = (0 + linear.size() - 1) / 2;
+        if (flattened.isEmpty()) {
+            throw new IllegalArgumentException("Matrix must contain at least one element.");
+        }
 
-        // Return the median
-        return linear.get(mid);
+        Collections.sort(flattened);
+        return flattened.get((flattened.size() - 1) / 2);
     }
 }
diff --git a/src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java b/src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java
@@ -2,17 +2,29 @@
 
 import java.util.Stack;
 
+/**
+ * Utility class for converting a non-negative decimal (base-10) integer
+ * to its representation in another radix (base) between 2 and 16, inclusive.
+ *
+ * <p>This class uses a stack-based approach to reverse the digits obtained from
+ * successive divisions by the target radix.
+ *
+ * <p>This class cannot be instantiated.</p>
+ */
 public final class DecimalToAnyUsingStack {
+
     private DecimalToAnyUsingStack() {
     }
 
+    private static final char[] DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
     /**
      * Convert a decimal number to another radix.
      *
      * @param number the number to be converted
      * @param radix the radix
      * @return the number represented in the new radix as a String
-     * @throws IllegalArgumentException if <tt>number</tt> is negative or <tt>radix</tt> is not between 2 and 16 inclusive
+     * @throws IllegalArgumentException if number is negative or radix is not between 2 and 16 inclusive
      */
     public static String convert(int number, int radix) {
         if (number < 0) {
@@ -26,18 +38,17 @@ public static String convert(int number, int radix) {
             return "0";
         }
 
-        char[] tables = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-        Stack<Character> bits = new Stack<>();
+        Stack<Character> digitStack = new Stack<>();
         while (number > 0) {
-            bits.push(tables[number % radix]);
-            number = number / radix;
+            digitStack.push(DIGITS[number % radix]);
+            number /= radix;
         }
 
-        StringBuilder result = new StringBuilder();
-        while (!bits.isEmpty()) {
-            result.append(bits.pop());
+        StringBuilder result = new StringBuilder(digitStack.size());
+        while (!digitStack.isEmpty()) {
+            result.append(digitStack.pop());
         }
+
         return result.toString();
     }
 }
diff --git a/src/test/java/com/thealgorithms/matrix/MedianOfMatrixTest.java b/src/test/java/com/thealgorithms/matrix/MedianOfMatrixTest.java
@@ -1,9 +1,11 @@
 package com.thealgorithms.matrix;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 
@@ -31,4 +33,18 @@ public void testMedianWithEvenNumberOfElements() {
 
         assertEquals(2, result);
     }
+
+    @Test
+    public void testMedianSingleElement() {
+        List<List<Integer>> matrix = new ArrayList<>();
+        matrix.add(List.of(1));
+
+        assertEquals(1, MedianOfMatrix.median(matrix));
+    }
+
+    @Test
+    void testEmptyMatrixThrowsException() {
+        Iterable<List<Integer>> emptyMatrix = Collections.emptyList();
+        assertThrows(IllegalArgumentException.class, () -> MedianOfMatrix.median(emptyMatrix), "Expected median() to throw, but it didn't");
+    }
 }
