Add Kruskal's algorithm for MST construction

Lord-of-Algorithms · Lord-of-Algorithms · commit 43e6ee6304e3 · 2024-07-21T19:28:26.000+03:00
diff --git a/src/graph/Edge.java b/src/graph/Edge.java
@@ -0,0 +1,51 @@
+package graph;
+
+import java.util.Objects;
+
+/**
+ * Represents an edge in a graph, defined by a source vertex,
+ * a destination vertex, and a weight.
+ */
+public class Edge {
+    private final Vertex source;
+    private final Vertex destination;
+    private final int weight;
+
+    public Edge(Vertex source, Vertex destination, int weight) {
+        this.source = source;
+        this.destination = destination;
+        this.weight = weight;
+    }
+
+    public Vertex getSource() {
+        return source;
+    }
+
+    public Vertex getDestination() {
+        return destination;
+    }
+
+    public int getWeight() {
+        return weight;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Edge edge = (Edge) o;
+        return weight == edge.weight &&
+                Objects.equals(source, edge.source) &&
+                Objects.equals(destination, edge.destination);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(source, destination, weight);
+    }
+
+    @Override
+    public String toString() {
+        return source + "" + destination + "(" + weight + ")";
+    }
+}
diff --git a/src/graph/mst/kruskal/KruskalMstMain.java b/src/graph/mst/kruskal/KruskalMstMain.java
@@ -0,0 +1,79 @@
+package graph.mst.kruskal;
+
+import graph.Edge;
+import graph.Vertex;
+import graph.VertexImpl;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Demonstrates the use of Kruskal's algorithm to find the minimum spanning tree (MST) of a graph.
+ * This class highlights how Kruskal's algorithm is particularly suited for graphs represented as a list of edges,
+ * as it processes edges by increasing weight, irrespective of their position in the graph. This edge list representation
+ * is used because Kruskal's algorithm does not require direct access to the graph's adjacency structure, making it
+ * efficient and straightforward for calculating the MST in graphs where edge connectivity is the primary concern.
+ * <p>
+ * The main method sets up vertices and edges, then uses Kruskal's algorithm to calculate and display the MST.
+ */
+public class KruskalMstMain {
+    public static void main(String[] args) {
+
+        List<Vertex> vertices = new ArrayList<>();
+        // Create vertices
+        Vertex a = new VertexImpl("A");
+        Vertex b = new VertexImpl("B");
+        Vertex c = new VertexImpl("C");
+        Vertex d = new VertexImpl("D");
+
+        vertices.add(a);
+        vertices.add(b);
+        vertices.add(c);
+        vertices.add(d);
+
+        List<Edge> edges = new ArrayList<>();
+        // Set edges between vertices with specified weights
+        edges.add(new Edge(a, b, 1));
+        edges.add(new Edge(d, b, 2));
+        edges.add(new Edge(b, c, 3));
+        edges.add(new Edge(a, d, 4));
+        edges.add(new Edge(d, c, 5));
+
+        // Calculate the MST using Kruskal's algorithm
+        List<Edge> mst = buildMst(vertices, edges);
+        System.out.println("MST: " + mst);
+    }
+
+    /**
+     * Constructs the minimum spanning tree (MST) for a graph represented by vertices and edges.
+     * Assumes that the graph is connected.
+     */
+    private static List<Edge> buildMst(List<Vertex> vertices, List<Edge> edges) {
+        if (vertices == null || vertices.isEmpty()) {
+            throw new IllegalArgumentException("Vertex list cannot be null or empty.");
+        }
+        if (edges == null || edges.isEmpty()) {
+            throw new IllegalArgumentException("Edge list cannot be null or empty.");
+        }
+
+        List<Edge> mst = new ArrayList<>();
+
+        // Sorting edges by weight
+        edges.sort(new Comparator<Edge>() {
+            @Override
+            public int compare(Edge edge1, Edge edge2) {
+                return edge1.getWeight() - edge2.getWeight();
+            }
+        });
+        UnionFind uf = new UnionFind(vertices);
+
+        for (Edge edge : edges) {
+            if (uf.find(edge.getSource()) != uf.find(edge.getDestination())) {
+                mst.add(edge);
+                uf.union(edge.getSource(), edge.getDestination());
+            }
+        }
+        return mst;
+    }
+}
diff --git a/src/graph/mst/kruskal/UnionFind.java b/src/graph/mst/kruskal/UnionFind.java
@@ -0,0 +1,57 @@
+package graph.mst.kruskal;
+
+import graph.Vertex;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implements the union-find data structure.
+ */
+class UnionFind {
+    private final Map<Vertex, Vertex> parent;
+    private final Map<Vertex, Integer> rank;
+
+    /**
+     * Constructs a union-find structure with a list of initial vertices.
+     * Each vertex is initially its own set with a rank of 0.
+     */
+    UnionFind(List<Vertex> vertices) {
+        parent = new HashMap<>();
+        rank = new HashMap<>();
+        for (Vertex vertex : vertices) {
+            parent.put(vertex, vertex);
+            rank.put(vertex, 0);
+        }
+    }
+
+    /**
+     * Finds the representative of the set containing the specified vertex.
+     * Implements path compression.
+     */
+    Vertex find(Vertex vertex) {
+        if (!vertex.equals(parent.get(vertex))) {
+            parent.put(vertex, find(parent.get(vertex)));
+        }
+        return parent.get(vertex);
+    }
+
+    /**
+     * Unites the two sets that contain vertex 'x' and 'y'.
+     */
+    void union(Vertex x, Vertex y) {
+        Vertex rootX = find(x);
+        Vertex rootY = find(y);
+        if (!rootX.equals(rootY)) {
+            if (rank.get(rootX) < rank.get(rootY)) {
+                parent.put(rootX, rootY);
+            } else if (rank.get(rootX) > rank.get(rootY)) {
+                parent.put(rootY, rootX);
+            } else {
+                parent.put(rootY, rootX);
+                rank.put(rootX, rank.get(rootX) + 1);
+            }
+        }
+    }
+}
