Create KruskalsAlgorithm.java

A greedy algorithm that sorts edges and includes them one by one, ensuring no cycles are formed.

DSA/Graph/KruskalsAlgorithm.java

@@ -0,0 +1,110 @@
+import java.util.*;
+
+class KruskalsAlgorithm {
+    class Edge implements Comparable<Edge> {
+        int src, dest, weight;
+        public int compareTo(Edge compareEdge) {
+            return this.weight - compareEdge.weight;
+        }
+    }
+
+    class Subset {
+        int parent, rank;
+    }
+
+    int V, E;
+    Edge edge[];
+
+    KruskalsAlgorithm(int v, int e) {
+        V = v;
+        E = e;
+        edge = new Edge[E];
+        for (int i = 0; i < e; ++i) {
+            edge[i] = new Edge();
+        }
+    }
+
+    int find(Subset subsets[], int i) {
+        if (subsets[i].parent != i) {
+            subsets[i].parent = find(subsets, subsets[i].parent);
+        }
+        return subsets[i].parent;
+    }
+
+    void union(Subset subsets[], int x, int y) {
+        int xroot = find(subsets, x);
+        int yroot = find(subsets, y);
+
+        if (subsets[xroot].rank < subsets[yroot].rank) {
+            subsets[xroot].parent = yroot;
+        } else if (subsets[xroot].rank > subsets[yroot].rank) {
+            subsets[yroot].parent = xroot;
+        } else {
+            subsets[yroot].parent = xroot;
+            subsets[xroot].rank++;
+        }
+    }
+
+    void kruskalMST() {
+        Edge result[] = new Edge[V];
+        int e = 0;
+        int i = 0;
+        for (i = 0; i < V; ++i) {
+            result[i] = new Edge();
+        }
+        Arrays.sort(edge);
+        Subset subsets[] = new Subset[V];
+        for (i = 0; i < V; ++i) {
+            subsets[i] = new Subset();
+        }
+
+        for (int v = 0; v < V; ++v) {
+            subsets[v].parent = v;
+            subsets[v].rank = 0;
+        }
+
+        i = 0;
+        while (e < V - 1) {
+            Edge nextEdge = edge[i++];
+            int x = find(subsets, nextEdge.src);
+            int y = find(subsets, nextEdge.dest);
+            if (x != y) {
+                result[e++] = nextEdge;
+                union(subsets, x, y);
+            }
+        }
+
+        System.out.println("Following are the edges in the constructed MST:");
+        for (i = 0; i < e; ++i) {
+            System.out.println(result[i].src + " -- " + result[i].dest + " == " + result[i].weight);
+        }
+    }
+
+    public static void main(String[] args) {
+        int V = 4;
+        int E = 5;
+        KruskalsAlgorithm graph = new KruskalsAlgorithm(V, E);
+
+        graph.edge[0].src = 0;
+        graph.edge[0].dest = 1;
+        graph.edge[0].weight = 10;
+
+        graph.edge[1].src = 0;
+        graph.edge[1].dest = 2;
+        graph.edge[1].weight = 6;
+
+        graph.edge[2].src = 0;
+        graph.edge[2].dest = 3;
+        graph.edge[2].weight = 5;
+
+        graph.edge[3].src = 1;
+        graph.edge[3].dest = 3;
+        graph.edge[3].weight = 15;
+
+        graph.edge[4].src = 2;
+        graph.edge[4].dest = 3;
+        graph.edge[4].weight = 4;
+
+        graph.kruskalMST();
+    }
+}