Merge branch 'master' into optimal-binary-search-tree

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/backtracking/WordSearch.java

@@ -35,51 +35,34 @@
  *  - Stack space for the recursive DFS function, where L is the maximum depth of recursion (length of the word).
  */
 public class WordSearch {
-    private final int[] dx = {0, 0, 1, -1};
-    private final int[] dy = {1, -1, 0, 0};
-    private boolean[][] visited;
-    private char[][] board;
-    private String word;
-
-    /**
-     * Checks if the given (x, y) coordinates are valid positions in the board.
-     *
-     * @param x The row index.
-     * @param y The column index.
-     * @return True if the coordinates are within the bounds of the board; false otherwise.
-     */
-    private boolean isValid(int x, int y) {
-        return x >= 0 && x < board.length && y >= 0 && y < board[0].length;
-    }
 
     /**
      * Performs Depth First Search (DFS) from the cell (x, y)
      * to search for the next character in the word.
      *
      * @param x       The current row index.
      * @param y       The current column index.
-     * @param nextIdx The index of the next character in the word to be matched.
+     * @param idx The index of the next character in the word to be matched.
      * @return True if a valid path is found to match the remaining characters of the word; false otherwise.
      */
-    private boolean doDFS(int x, int y, int nextIdx) {
-        visited[x][y] = true;
-        if (nextIdx == word.length()) {
+
+    private boolean dfs(char[][] board, int x, int y, String word, int idx) {
+        if (idx == word.length()) {
             return true;
         }
 
-        for (int i = 0; i < 4; ++i) {
-            int xi = x + dx[i];
-            int yi = y + dy[i];
-            if (isValid(xi, yi) && board[xi][yi] == word.charAt(nextIdx) && !visited[xi][yi]) {
-                boolean exists = doDFS(xi, yi, nextIdx + 1);
-                if (exists) {
-                    return true;
-                }
-            }
+        if (x < 0 || y < 0 || x >= board.length || y >= board[0].length || board[x][y] != word.charAt(idx)) {
+            return false;
         }
 
-        visited[x][y] = false; // Backtrack
-        return false;
+        char temp = board[x][y];
+        board[x][y] = '#';
+
+        boolean found = dfs(board, x + 1, y, word, idx + 1) || dfs(board, x - 1, y, word, idx + 1) || dfs(board, x, y + 1, word, idx + 1) || dfs(board, x, y - 1, word, idx + 1);
+
+        board[x][y] = temp;
+
+        return found;
     }
 
     /**
@@ -90,20 +73,21 @@ private boolean doDFS(int x, int y, int nextIdx) {
      * @param word  The target word to search for in the board.
      * @return True if the word exists in the board; false otherwise.
      */
+
     public boolean exist(char[][] board, String word) {
-        this.board = board;
-        this.word = word;
-        for (int i = 0; i < board.length; ++i) {
-            for (int j = 0; j < board[0].length; ++j) {
-                if (board[i][j] == word.charAt(0)) {
-                    visited = new boolean[board.length][board[0].length];
-                    boolean exists = doDFS(i, j, 1);
-                    if (exists) {
-                        return true;
-                    }
+
+        int m = board.length;
+        int n = board[0].length;
+
+        // DFS search
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (board[i][j] == word.charAt(0) && dfs(board, i, j, word, 0)) {
+                    return true;
                 }
             }
         }
+
         return false;
     }
 }

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/Correlation.java

@@ -0,0 +1,51 @@
+package com.thealgorithms.maths;
+
+/**
+ * Class for correlation of two discrete variables
+ */
+
+public final class Correlation {
+    private Correlation() {
+    }
+
+    public static final double DELTA = 1e-9;
+
+    /**
+     * Discrete correlation function.
+     * Correlation between two discrete variables is calculated
+     * according to the formula: Cor(x, y)=Cov(x, y)/sqrt(Var(x)*Var(y)).
+     * Correlation with a constant variable is taken to be zero.
+     *
+     * @param x The first discrete variable
+     * @param y The second discrete variable
+     * @param n The number of values for each variable
+     * @return The result of the correlation of variables x,y.
+     */
+    public static double correlation(double[] x, double[] y, int n) {
+        double exy = 0; // E(XY)
+        double ex = 0; // E(X)
+        double exx = 0; // E(X^2)
+        double ey = 0; // E(Y)
+        double eyy = 0; // E(Y^2)
+        for (int i = 0; i < n; i++) {
+            exy += x[i] * y[i];
+            ex += x[i];
+            exx += x[i] * x[i];
+            ey += y[i];
+            eyy += y[i] * y[i];
+        }
+        exy /= n;
+        ex /= n;
+        exx /= n;
+        ey /= n;
+        eyy /= n;
+        double cov = exy - ex * ey; // Cov(X, Y) = E(XY)-E(X)E(Y)
+        double varx = Math.sqrt(exx - ex * ex); // Var(X) = sqrt(E(X^2)-E(X)^2)
+        double vary = Math.sqrt(eyy - ey * ey); // Var(Y) = sqrt(E(Y^2)-E(Y)^2)
+        if (varx * vary < DELTA) { // Var(X) = 0 means X = const, the same about Y
+            return 0;
+        } else {
+            return cov / Math.sqrt(varx * vary);
+        }
+    }
+}

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

@@ -1,23 +1,19 @@
 package com.thealgorithms.maths;
 
+import java.math.BigInteger;
+
 public final class Factorial {
     private Factorial() {
     }
 
-    /**
-     * Calculate factorial N using iteration
-     *
-     * @param n the number
-     * @return the factorial of {@code n}
-     */
-    public static long factorial(int n) {
+    public static BigInteger factorial(int n) {
         if (n < 0) {
             throw new IllegalArgumentException("Input number cannot be negative");
         }
-        long factorial = 1;
-        for (int i = 1; i <= n; ++i) {
-            factorial *= i;
+        BigInteger result = BigInteger.ONE;
+        for (int i = 1; i <= n; i++) {
+            result = result.multiply(BigInteger.valueOf(i));
         }
-        return factorial;
+        return result;
     }
 }

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

@@ -107,6 +107,28 @@ public static Double harmonic(final Iterable<Double> numbers) {
         return size / sumOfReciprocals;
     }
 
+    /**
+     * Computes the quadratic mean (root mean square) of the given numbers.
+     * <p>
+     * The quadratic mean is calculated as: √[(x₁^2 × x₂^2 × ... × xₙ^2)/n]
+     * </p>
+     * <p>
+     * Example: For numbers [1, 7], the quadratic mean is √[(1^2+7^2)/2] = √25 = 5.0
+     * </p>
+     *
+     * @param numbers the input numbers (must not be empty)
+     * @return the quadratic mean of the input numbers
+     * @throws IllegalArgumentException if the input is empty
+     * @see <a href="https://en.wikipedia.org/wiki/Root_mean_square">Quadratic
+     *      Mean</a>
+     */
+    public static Double quadratic(final Iterable<Double> numbers) {
+        checkIfNotEmpty(numbers);
+        double sumOfSquares = StreamSupport.stream(numbers.spliterator(), false).reduce(0d, (x, y) -> x + y * y);
+        int size = IterableUtils.size(numbers);
+        return Math.pow(sumOfSquares / size, 0.5);
+    }
+
     /**
      * Validates that the input iterable is not empty.
      *

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/physics/ElasticCollision2D.java

@@ -41,7 +41,7 @@ public static void resolveCollision(Body a, Body b) {
         double dy = b.y - a.y;
         double dist = Math.hypot(dx, dy);
 
-        if (dist == 0) {
+        if (dist < a.radius + b.radius) {
             return; // overlapping
         }