Merge branch 'master' into patch-7

Author: DenizAltunkapan

.github/workflows/build.yml

@@ -20,15 +20,15 @@ jobs:
         if: >-
           github.event_name == 'pull_request' &&
           github.event.pull_request.head.repo.full_name != github.repository
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v6
         with:
           fail_ci_if_error: true
       - name: Upload coverage to codecov (with token)
         if: >
           github.repository == 'TheAlgorithms/Java' &&
           (github.event_name != 'pull_request' ||
           github.event.pull_request.head.repo.full_name == github.repository)
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v6
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           fail_ci_if_error: true

pom.xml

@@ -112,14 +112,14 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.3.0</version>
+                    <version>13.4.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.9.8.2</version>
+                <version>4.9.8.3</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

src/main/java/com/thealgorithms/graph/TarjanBridges.java

@@ -0,0 +1,122 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implementation of Tarjan's Bridge-Finding Algorithm for undirected graphs.
+ *
+ * <p>A <b>bridge</b> (also called a cut-edge) is an edge in an undirected graph whose removal
+ * increases the number of connected components. Bridges represent critical links
+ * in a network — if any bridge is removed, part of the network becomes unreachable.</p>
+ *
+ * <p>The algorithm performs a single Depth-First Search (DFS) traversal, tracking two
+ * values for each vertex:</p>
+ * <ul>
+ *   <li><b>discoveryTime</b> — the time step at which the vertex was first visited.</li>
+ *   <li><b>lowLink</b> — the smallest discovery time reachable from the subtree rooted
+ *       at that vertex (via back edges).</li>
+ * </ul>
+ *
+ * <p>An edge (u, v) is a bridge if and only if {@code lowLink[v] > discoveryTime[u]},
+ * meaning there is no back edge from the subtree of v that can reach u or any ancestor of u.</p>
+ *
+ * <p>Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges.</p>
+ * <p>Space Complexity: O(V + E) for the adjacency list, discovery/low arrays, and recursion stack.</p>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Bridge_(graph_theory)">Wikipedia: Bridge (graph theory)</a>
+ */
+public final class TarjanBridges {
+
+    private TarjanBridges() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    /**
+     * Finds all bridge edges in an undirected graph.
+     *
+     * <p>The graph is represented as an adjacency list where each vertex is identified by
+     * an integer in the range {@code [0, vertexCount)}. For each undirected edge (u, v),
+     * v must appear in {@code adjacencyList.get(u)} and u must appear in
+     * {@code adjacencyList.get(v)}.</p>
+     *
+     * @param vertexCount   the total number of vertices in the graph (must be non-negative)
+     * @param adjacencyList the adjacency list representation of the graph; must contain
+     *                      exactly {@code vertexCount} entries (one per vertex)
+     * @return a list of bridge edges, where each bridge is represented as an {@code int[]}
+     *         of length 2 with {@code edge[0] < edge[1]}; returns an empty list if no bridges exist
+     * @throws IllegalArgumentException if {@code vertexCount} is negative, or if
+     *                                  {@code adjacencyList} is null or its size does not match
+     *                                  {@code vertexCount}
+     */
+    public static List<int[]> findBridges(int vertexCount, List<List<Integer>> adjacencyList) {
+        if (vertexCount < 0) {
+            throw new IllegalArgumentException("vertexCount must be non-negative");
+        }
+        if (adjacencyList == null || adjacencyList.size() != vertexCount) {
+            throw new IllegalArgumentException("adjacencyList size must equal vertexCount");
+        }
+
+        List<int[]> bridges = new ArrayList<>();
+
+        if (vertexCount == 0) {
+            return bridges;
+        }
+
+        BridgeFinder finder = new BridgeFinder(vertexCount, adjacencyList, bridges);
+
+        // Run DFS from every unvisited vertex to handle disconnected graphs
+        for (int i = 0; i < vertexCount; i++) {
+            if (!finder.visited[i]) {
+                finder.dfs(i, -1);
+            }
+        }
+
+        return bridges;
+    }
+
+    private static class BridgeFinder {
+        private final List<List<Integer>> adjacencyList;
+        private final List<int[]> bridges;
+        private final int[] discoveryTime;
+        private final int[] lowLink;
+        boolean[] visited;
+        private int timer;
+
+        BridgeFinder(int vertexCount, List<List<Integer>> adjacencyList, List<int[]> bridges) {
+            this.adjacencyList = adjacencyList;
+            this.bridges = bridges;
+            this.discoveryTime = new int[vertexCount];
+            this.lowLink = new int[vertexCount];
+            this.visited = new boolean[vertexCount];
+            this.timer = 0;
+        }
+
+        /**
+         * Performs DFS from the given vertex, computing discovery times and low-link values,
+         * and collects any bridge edges found.
+         *
+         * @param u      the current vertex being explored
+         * @param parent the parent of u in the DFS tree (-1 if u is a root)
+         */
+        void dfs(int u, int parent) {
+            visited[u] = true;
+            discoveryTime[u] = timer;
+            lowLink[u] = timer;
+            timer++;
+
+            for (int v : adjacencyList.get(u)) {
+                if (!visited[v]) {
+                    dfs(v, u);
+                    lowLink[u] = Math.min(lowLink[u], lowLink[v]);
+
+                    if (lowLink[v] > discoveryTime[u]) {
+                        bridges.add(new int[] {Math.min(u, v), Math.max(u, v)});
+                    }
+                } else if (v != parent) {
+                    lowLink[u] = Math.min(lowLink[u], discoveryTime[v]);
+                }
+            }
+        }
+    }
+}

src/main/java/com/thealgorithms/maths/Volume.java

@@ -125,4 +125,16 @@ public static double volumeFrustumOfPyramid(double upperBaseArea, double lowerBa
     public static double volumeTorus(double majorRadius, double minorRadius) {
         return 2 * Math.PI * Math.PI * majorRadius * minorRadius * minorRadius;
     }
+
+    /**
+     * Calculate the volume of an ellipsoid.
+     *
+     * @param a first semi-axis of an ellipsoid
+     * @param b second semi-axis of an ellipsoid
+     * @param c third semi-axis of an ellipsoid
+     * @return volume of the ellipsoid
+     */
+    public static double volumeEllipsoid(double a, double b, double c) {
+        return (4 * Math.PI * a * b * c) / 3;
+    }
 }

src/main/java/com/thealgorithms/searches/InterpolationSearch.java

@@ -1,3 +1,14 @@
+/**
+ * Interpolation Search estimates the position of the target value
+ * based on the distribution of values.
+ *
+ * Example:
+ * Input: [10, 20, 30, 40], target = 30
+ * Output: Index = 2
+ *
+ * Time Complexity: O(log log n) (average case)
+ * Space Complexity: O(1)
+ */
 package com.thealgorithms.searches;
 
 /**

src/main/java/com/thealgorithms/searches/IterativeBinarySearch.java

@@ -3,50 +3,53 @@
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
 
 /**
- * Binary search is one of the most popular algorithms This class represents
- * iterative version {@link BinarySearch} Iterative binary search is likely to
- * have lower constant factors because it doesn't involve the overhead of
- * manipulating the call stack. But in java the recursive version can be
- * optimized by the compiler to this version.
+ * Binary search is one of the most popular algorithms.
+ * This class represents the iterative version of {@link BinarySearch}.
  *
- * <p>
- * Worst-case performance O(log n) Best-case performance O(1) Average
- * performance O(log n) Worst-case space complexity O(1)
+ * <p>Iterative binary search avoids recursion overhead and uses constant space.
  *
- * @author Gabriele La Greca : https://github.com/thegabriele97
- * @author Podshivalov Nikita (https://github.com/nikitap492)
+ * <p>Performance:
+ * <ul>
+ *   <li>Best-case: O(1)</li>
+ *   <li>Average-case: O(log n)</li>
+ *   <li>Worst-case: O(log n)</li>
+ *   <li>Space complexity: O(1)</li>
+ * </ul>
+ *
+ * @author Gabriele La Greca
+ * @author Podshivalov Nikita
  * @see SearchAlgorithm
  * @see BinarySearch
  */
 public final class IterativeBinarySearch implements SearchAlgorithm {
 
     /**
-     * This method implements an iterative version of binary search algorithm
+     * Performs iterative binary search on a sorted array.
      *
-     * @param array a sorted array
-     * @param key the key to search in array
-     * @return the index of key in the array or -1 if not found
+     * @param array the sorted array
+     * @param key the element to search
+     * @param <T> type of elements (must be Comparable)
+     * @return index of the key if found, otherwise -1
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
-        int l;
-        int r;
-        int k;
-        int cmp;
+        if (array == null || array.length == 0) {
+            return -1;
+        }
 
-        l = 0;
-        r = array.length - 1;
+        int left = 0;
+        int right = array.length - 1;
 
-        while (l <= r) {
-            k = (l + r) >>> 1;
-            cmp = key.compareTo(array[k]);
+        while (left <= right) {
+            int mid = (left + right) >>> 1;
+            int cmp = key.compareTo(array[mid]);
 
             if (cmp == 0) {
-                return k;
+                return mid;
             } else if (cmp < 0) {
-                r = --k;
+                right = mid - 1;
             } else {
-                l = ++k;
+                left = mid + 1;
             }
         }
 

src/main/java/com/thealgorithms/searches/JumpSearch.java

@@ -12,26 +12,50 @@
  * Once the range is found, a linear search is performed within that block.
  *
  * <p>
- * The Jump Search algorithm is particularly effective for large sorted arrays where the cost of
- * performing a linear search on the entire array would be prohibitive.
+ * <b>How it works:</b>
+ * <ol>
+ *   <li>Calculate the optimal block size as √n (square root of array length)</li>
+ *   <li>Jump ahead by the block size until the current element is greater than the target</li>
+ *   <li>Perform a linear search backwards within the identified block</li>
+ * </ol>
  *
  * <p>
- * Worst-case performance: O(√N)<br>
- * Best-case performance: O(1)<br>
- * Average performance: O(√N)<br>
- * Worst-case space complexity: O(1)
+ * <b>Example:</b><br>
+ * Array: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19], Target: 9<br>
+ * Step 1: Jump from index 0 → 3 → 6 (9 < 13, so we found the block)<br>
+ * Step 2: Linear search from index 3 to 6: found 9 at index 4<br>
+ * Result: Index = 4
+ *
+ * <p>
+ * <b>Time Complexity:</b><br>
+ * - Best-case: O(1) - element found at first position<br>
+ * - Average: O(√n) - optimal block size reduces jumps<br>
+ * - Worst-case: O(√n) - element at end of array or not present<br>
+ *
+ * <p>
+ * <b>Space Complexity:</b> O(1) - only uses a constant amount of extra space
+ *
+ * <p>
+ * <b>Note:</b> Jump Search requires a sorted array. For unsorted arrays, use Linear Search.
+ * Compared to Linear Search (O(n)), Jump Search is faster for large arrays.
+ * Compared to Binary Search (O(log n)), Jump Search is less efficient but may be
+ * preferable when jumping through a linked list or when backward scanning is costly.
  *
  * <p>
  * This class implements the {@link SearchAlgorithm} interface, providing a generic search method
  * for any comparable type.
+ *
+ * @see SearchAlgorithm
+ * @see BinarySearch
+ * @see LinearSearch
  */
 public class JumpSearch implements SearchAlgorithm {
 
     /**
      * Jump Search algorithm implementation.
      *
-     * @param array the sorted array containing elements
-     * @param key   the element to be searched
+     * @param array the sorted array containing elements (must be sorted in ascending order)
+     * @param key   the element to be searched for
      * @return the index of {@code key} if found, otherwise -1
      */
     @Override

src/main/java/com/thealgorithms/searches/LinearSearch.java

@@ -1,3 +1,16 @@
+/**
+ * Performs Linear Search on an array.
+ *
+ * Linear search checks each element one by one until the target is found
+ * or the array ends.
+ *
+ * Example:
+ * Input: [2, 4, 6, 8], target = 6
+ * Output: Index = 2
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(1)
+ */
 package com.thealgorithms.searches;
 
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
@@ -28,10 +41,13 @@ public class LinearSearch implements SearchAlgorithm {
      *
      * @param array List to be searched
      * @param value Key being searched for
-     * @return Location of the key
+     * @return Location of the key, -1 if array is null or empty, or key not found
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T value) {
+        if (array == null || array.length == 0) {
+            return -1;
+        }
         for (int i = 0; i < array.length; i++) {
             if (array[i].compareTo(value) == 0) {
                 return i;