fix: format code, add Wikipedia reference, and clean up javadoc

Author: saikirankanakala

src/main/java/com/thealgorithms/greedyalgorithms/KruskalAlgorithm.java

@@ -14,34 +14,27 @@
  *   <li>Using Union-Find (Disjoint Set Union) to efficiently detect cycles</li>
  * </ol>
  *
- * <p><strong>Time Complexity:</strong> O(E log E) or O(E log V), where E is the number of edges
+ * <p>Time Complexity: O(E log E) or O(E log V), where E is the number of edges
  * and V is the number of vertices. Sorting edges dominates the complexity.
  *
- * <p><strong>Space Complexity:</strong> O(V) for the Union-Find data structure.
+ * <p>Space Complexity: O(V) for the Union-Find data structure.
  *
- * @author guillermolara01
+ * @see <a href="https://en.wikipedia.org/wiki/Kruskal%27s_algorithm">Kruskal's Algorithm</a>
+ * @author saikirankanakala
  */
 public final class KruskalAlgorithm {
 
     private KruskalAlgorithm() {
-        // Utility class, prevent instantiation
     }
 
     /**
      * Represents a weighted edge in an undirected graph.
      */
-    public static class Edge implements Comparable<Edge> {
+    public static final class Edge implements Comparable<Edge> {
         private final int source;
         private final int destination;
         private final int weight;
 
-        /**
-         * Creates an edge with the specified endpoints and weight.
-         *
-         * @param source the source vertex
-         * @param destination the destination vertex
-         * @param weight the weight of the edge
-         */
         public Edge(int source, int destination, int weight) {
             this.source = source;
             this.destination = destination;
@@ -72,18 +65,12 @@ public String toString() {
     }
 
     /**
-     * Union-Find (Disjoint Set Union) data structure with path compression
-     * and union by rank for efficient cycle detection.
+     * Union-Find data structure with path compression and union by rank.
      */
-    private static class UnionFind {
+    private static final class UnionFind {
         private final int[] parent;
         private final int[] rank;
 
-        /**
-         * Initializes the Union-Find structure with n elements.
-         *
-         * @param n the number of elements
-         */
         UnionFind(int n) {
             parent = new int[n];
             rank = new int[n];
@@ -93,37 +80,21 @@ private static class UnionFind {
             }
         }
 
-        /**
-         * Finds the representative (root) of the set containing element x.
-         * Uses path compression for optimization.
-         *
-         * @param x the element to find
-         * @return the representative of the set
-         */
         int find(int x) {
             if (parent[x] != x) {
-                parent[x] = find(parent[x]); // Path compression
+                parent[x] = find(parent[x]);
             }
             return parent[x];
         }
 
-        /**
-         * Unites the sets containing elements x and y.
-         * Uses union by rank for optimization.
-         *
-         * @param x the first element
-         * @param y the second element
-         * @return true if the sets were merged, false if they were already in the same set
-         */
         boolean union(int x, int y) {
             int rootX = find(x);
             int rootY = find(y);
 
             if (rootX == rootY) {
-                return false; // Already in the same set (would create a cycle)
+                return false;
             }
 
-            // Union by rank
             if (rank[rootX] < rank[rootY]) {
                 parent[rootX] = rootY;
             } else if (rank[rootX] > rank[rootY]) {
@@ -137,11 +108,11 @@ boolean union(int x, int y) {
     }
 
     /**
-     * Finds the Minimum Spanning Tree of a graph using Kruskal's algorithm.
+     * Finds the Minimum Spanning Tree using Kruskal's algorithm.
      *
      * @param vertices the number of vertices in the graph
      * @param edges the list of edges in the graph
-     * @return a list of edges that form the MST
+     * @return a list of edges forming the MST
      * @throws IllegalArgumentException if vertices is less than 1 or edges is null
      */
     public static List<Edge> kruskal(int vertices, List<Edge> edges) {
@@ -157,18 +128,12 @@ public static List<Edge> kruskal(int vertices, List<Edge> edges) {
             return mst;
         }
 
-        // Sort edges by weight
         edges.sort(Edge::compareTo);
-
         UnionFind uf = new UnionFind(vertices);
 
-        // Iterate through sorted edges
         for (Edge edge : edges) {
-            // If adding this edge doesn't create a cycle, include it in MST
             if (uf.union(edge.getSource(), edge.getDestination())) {
                 mst.add(edge);
-
-                // MST is complete when we have (V-1) edges
                 if (mst.size() == vertices - 1) {
                     break;
                 }
@@ -182,7 +147,7 @@ public static List<Edge> kruskal(int vertices, List<Edge> edges) {
      * Calculates the total weight of the MST.
      *
      * @param mst the list of edges in the MST
-     * @return the total weight of all edges in the MST
+     * @return the total weight of all edges
      */
     public static int getMSTWeight(List<Edge> mst) {
         return mst.stream().mapToInt(Edge::getWeight).sum();

src/test/java/com/thealgorithms/greedyalgorithms/KruskalAlgorithmTest.java

@@ -12,13 +12,6 @@ class KruskalAlgorithmTest {
 
     @Test
     void testSimpleGraph() {
-        // Graph with 4 vertices
-        //     1
-        //   / | \
-        //  2  3  4
-        // 0---1---2
-        // |       |
-        // 3-------4
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         edges.add(new KruskalAlgorithm.Edge(0, 1, 10));
         edges.add(new KruskalAlgorithm.Edge(0, 2, 6));
@@ -28,35 +21,33 @@ void testSimpleGraph() {
 
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(4, edges);
 
-        assertEquals(3, mst.size(), "MST should have V-1 edges");
-        assertEquals(19, KruskalAlgorithm.getMSTWeight(mst), "Total MST weight should be 19");
+        assertEquals(3, mst.size());
+        assertEquals(19, KruskalAlgorithm.getMSTWeight(mst));
     }
 
     @Test
     void testDisconnectedGraph() {
-        // Two disconnected components
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         edges.add(new KruskalAlgorithm.Edge(0, 1, 1));
         edges.add(new KruskalAlgorithm.Edge(2, 3, 2));
 
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(4, edges);
 
-        assertEquals(2, mst.size(), "MST should include both components");
-        assertEquals(3, KruskalAlgorithm.getMSTWeight(mst), "Total MST weight should be 3");
+        assertEquals(2, mst.size());
+        assertEquals(3, KruskalAlgorithm.getMSTWeight(mst));
     }
 
     @Test
     void testSingleVertex() {
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(1, edges);
 
-        assertTrue(mst.isEmpty(), "MST of single vertex should be empty");
+        assertTrue(mst.isEmpty());
         assertEquals(0, KruskalAlgorithm.getMSTWeight(mst));
     }
 
     @Test
     void testCompleteGraph() {
-        // Complete graph with 4 vertices (K4)
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         edges.add(new KruskalAlgorithm.Edge(0, 1, 1));
         edges.add(new KruskalAlgorithm.Edge(0, 2, 2));
@@ -67,30 +58,29 @@ void testCompleteGraph() {
 
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(4, edges);
 
-        assertEquals(3, mst.size(), "MST should have V-1 edges");
-        assertEquals(6, KruskalAlgorithm.getMSTWeight(mst), "Total MST weight should be 6 (1+2+3)");
+        assertEquals(3, mst.size());
+        assertEquals(6, KruskalAlgorithm.getMSTWeight(mst));
     }
 
     @Test
     void testEqualWeights() {
-        // Graph where all edges have the same weight
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         edges.add(new KruskalAlgorithm.Edge(0, 1, 1));
         edges.add(new KruskalAlgorithm.Edge(1, 2, 1));
         edges.add(new KruskalAlgorithm.Edge(2, 0, 1));
 
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(3, edges);
 
-        assertEquals(2, mst.size(), "MST should have V-1 edges");
-        assertEquals(2, KruskalAlgorithm.getMSTWeight(mst), "Total MST weight should be 2");
+        assertEquals(2, mst.size());
+        assertEquals(2, KruskalAlgorithm.getMSTWeight(mst));
     }
 
     @Test
     void testEmptyGraph() {
         List<KruskalAlgorithm.Edge> edges = new ArrayList<>();
         List<KruskalAlgorithm.Edge> mst = KruskalAlgorithm.kruskal(5, edges);
 
-        assertTrue(mst.isEmpty(), "MST of empty graph should be empty");
+        assertTrue(mst.isEmpty());
     }
 
     @Test