Repository: TheAlgorithms/Java
File: src/main/java/com/thealgorithms/datastructures/graphs/BoruvkaAlgorithm.java (Java)

Code before:
        List<Edge> result = new ArrayList<>();

        // Initialize subsets for Union-Find
        Subset[] subsets = initializeSubsets(graph);

        // Continue until the number of edges in the MST is V-1
        while (result.size() < graph.vertex - 1) {
            // Array to store the cheapest edge for each subset
            Edge[] cheapest = new Edge[graph.vertex];

            // Iterate through all edges and update the cheapest edge for each subset
            updateCheapestEdges(graph, subsets, cheapest);

            // Add the cheapest edges to the result and perform Union operation
            addCheapestEdgesAndUnion(graph, subsets, result, cheapest);
        }
        return result;
    }

    /**
     * Initializes subsets for Union-Find
     *
     * @param graph the graph
     * @return the initialized subsets
     */
    private static Subset[] initializeSubsets(Graph graph) {
        Subset[] subsets = new Subset[graph.vertex];
        for (int v = 0; v < graph.vertex; ++v) {
            subsets[v] = new Subset(v, 0);
        }
        return subsets;
    }

    /**
     * Updates the cheapest edge for each subset based on the given graph and subsets
     *
     * @param graph    the graph
     * @param subsets  array of subsets
     * @param cheapest array to store the cheapest edge for each subset
     */
    private static void updateCheapestEdges(Graph graph, Subset[] subsets, Edge[] cheapest) {
        for (Edge edge : graph.edges) {
            int set1 = find(subsets, edge.src);
            int set2 = find(subsets, edge.dest);

            if (set1 != set2) {
                if (cheapest[set1] == null || edge.weight < cheapest[set1].weight) {
                    cheapest[set1] = edge;
                }
                if (cheapest[set2] == null || edge.weight < cheapest[set2].weight) {
                    cheapest[set2] = edge;

Review comment (suggestion):
```suggestion
    private static Subset[] initializeSubsets(final Graph graph) {
```

Code after:
        /**
         * Computes the cheapest edges for each subset in the Union-Find structure.
         *
         * @return an array containing the cheapest edge for each subset.
         */
        private Edge[] computeCheapestEdges() {
            Edge[] cheapest = new Edge[graph.vertex];
            for (final var edge : graph.edges) {
                final var set1 = find(components, edge.src);
                final var set2 = find(components, edge.dest);

                if (set1 != set2) {
                    if (cheapest[set1] == null || edge.weight < cheapest[set1].weight) {
                        cheapest[set1] = edge;
                    }
                    if (cheapest[set2] == null || edge.weight < cheapest[set2].weight) {
                        cheapest[set2] = edge;
                    }
                }
            }
            return cheapest;
        }

        /**
         * Initializes subsets for Union-Find
         *
         * @param graph the graph
         * @return the initialized subsets
         */
        private static Component[] initializeComponents(final Graph graph) {
            Component[] components = new Component[graph.vertex];
            for (int v = 0; v < graph.vertex; ++v) {
                components[v] = new Component(v, 0);
            }
            return components;
        }
    }

    /**
     * Finds the parent of the subset using path compression
     *
     * @param components array of subsets
     * @param i          index of the subset
     * @return the parent of the subset
     */
    static int find(final Component[] components, final int i) {
        if (components[i].parent != i) {
            components[i].parent = find(components, components[i].parent);
        }
        return components[i].parent;
    }