Add Kruskal and Prim implementation

Author: junnengsoo

src/main/java/algorithms/minimumSpanningTree/kruskal/Kruskal.java

@@ -0,0 +1,134 @@
+package algorithms.minimumSpanningTree.kruskal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import dataStructures.disjointSet.weightedUnion.DisjointSet;
+
+/**
+ * Implementation of Kruskal's Algorithm to find MSTs
+ * Idea:
+ *  Sort all edges by weight in non-decreasing order. Consider the edges in this order. If an edge does not form a cycle
+ *  with the edges already in the MST, add it to the MST. Repeat until all nodes are in the MST.
+ * Actual implementation:
+ *  An Edge class is implemented for easier sorting of edges by weight and for identifying the source and destination.
+ *  A Node class is implemented for easier tracking of nodes in the graph for the disjoint set.
+ *  A DisjointSet class is used to track the nodes in the graph and to determine if adding an edge will form a cycle.
+ */
+public class Kruskal {
+    public static int[][] getKruskalMST(Node[] nodes, int[][] adjacencyMatrix) {
+        int numOfNodes = nodes.length;
+        List<Edge> edges = new ArrayList<>();
+
+        // Convert adjacency matrix to list of edges
+        for (int i = 0; i < numOfNodes; i++) {
+            for (int j = i + 1; j < numOfNodes; j++) {
+                if (adjacencyMatrix[i][j] != Integer.MAX_VALUE) {
+                    edges.add(new Edge(nodes[i], nodes[j], adjacencyMatrix[i][j]));
+                }
+            }
+        }
+
+        // Sort edges by weight
+        edges.sort(Edge::compareTo);
+
+        // Initialize Disjoint Set for vertex tracking
+        DisjointSet<Node> ds = new DisjointSet<>(nodes);
+
+        // MST adjacency matrix to be returned
+        int[][] mstMatrix = new int[numOfNodes][numOfNodes];
+
+        // Initialize the MST matrix to represent no edges with Integer.MAX_VALUE and 0 for self loops
+        for (int i = 0; i < nodes.length; i++) {
+            for (int j = 0; j < nodes.length; j++) {
+                mstMatrix[i][j] = (i == j) ? 0 : Integer.MAX_VALUE;
+            }
+        }
+
+        // Process edges to build MST
+        for (Edge edge : edges) {
+            Node source = edge.getSource();
+            Node destination = edge.getDestination();
+            if (!ds.find(source, destination)) {
+                mstMatrix[source.getIndex()][destination.getIndex()] = edge.getWeight();
+                mstMatrix[destination.getIndex()][source.getIndex()] = edge.getWeight();
+                ds.union(source, destination);
+            }
+        }
+
+        return mstMatrix;
+    }
+
+    /**
+     * Node class to represent a node in the graph
+     * Note: In our Node class, we do not allow the currMinWeight to be updated after initialization to prevent any
+     * reference issues in the PriorityQueue.
+     */
+    static class Node {
+        private final int index; // Index of this node in the adjacency matrix
+        private final String identifier;
+
+        /**
+         * Constructor for Node
+         * @param identifier
+         * @param index
+         */
+        public Node(String identifier, int index) {
+            this.identifier = identifier;
+            this.index = index;
+        }
+
+        /**
+         * Getter for identifier
+         * @return identifier
+         */
+        public String getIdentifier() {
+            return identifier;
+        }
+
+        public int getIndex() {
+            return index;
+        }
+
+        @Override
+        public String toString() {
+            return "Node{" + "identifier='" + identifier + '\'' + ", index=" + index + '}';
+        }
+    }
+
+    /**
+     * Edge class to represent an edge in the graph
+     */
+    static class Edge implements Comparable<Edge> {
+        private final Node source;
+        private final Node destination;
+        private final int weight;
+
+        /**
+         * Constructor for Edge
+         */
+        public Edge(Node source, Node destination, int weight) {
+            this.source = source;
+            this.destination = destination;
+            this.weight = weight;
+        }
+
+        public int getWeight() {
+            return weight;
+        }
+
+        public Node getSource() {
+            return source;
+        }
+
+        public Node getDestination() {
+            return destination;
+        }
+
+        @Override
+        public int compareTo(Edge other) {
+            return Integer.compare(this.weight, other.weight);
+        }
+    }
+}
+

src/main/java/algorithms/minimumSpanningTree/prim/Prim.java

@@ -0,0 +1,135 @@
+package algorithms.minimumSpanningTree.prim;
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+/**
+ * Implementation of Prim's Algorithm to find MSTs
+ * Idea:
+ *  Starting from any source (this will be the first node to be in the MST), pick the lightest outgoing edge, and
+ *  include the node at the other end as part of a set of nodes S. Now repeatedly do the above by picking the lightest
+ *  outgoing edge adjacent to any node in the MST (ensure the other end of the node is not already in the MST).
+ *  Repeat until S contains all nodes in the graph. S is the MST.
+ * Actual implementation:
+ *  No Edge class was implemented. Instead, the weights of the edges are stored in a 2D array adjacency matrix. An
+ *  adjacency list may be used instead
+ *  A Node class is implemented to encapsulate the current minimum weight to reach the node.
+ */
+public class Prim {
+    public static int[][] getPrimsMST(Node[] nodes, int[][] adjacencyMatrix) {
+        // Recall that PriorityQueue is a min heap by default
+        PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> a.getCurrMinWeight() - b.getCurrMinWeight());
+        int[][] mstMatrix = new int[nodes.length][nodes.length]; // MST adjacency matrix
+
+        int[] parent = new int[nodes.length]; // To track the parent node of each node in the MST
+        Arrays.fill(parent, -1); // Initialize parent array with -1, indicating no parent
+
+        boolean[] visited = new boolean[nodes.length]; // To track visited nodes
+        Arrays.fill(visited, false); // Initialize visited array with false, indicating not visited
+
+        // Initialize the MST matrix to represent no edges with Integer.MAX_VALUE and 0 for self loops
+        for (int i = 0; i < nodes.length; i++) {
+            for (int j = 0; j < nodes.length; j++) {
+                mstMatrix[i][j] = (i == j) ? 0 : Integer.MAX_VALUE;
+            }
+        }
+
+        // Add all nodes to the priority queue, with each node's curr min weight already set to Integer.MAX_VALUE
+        pq.addAll(Arrays.asList(nodes));
+
+        while (!pq.isEmpty()) {
+            Node current = pq.poll();
+
+            int currentIndex = current.getIndex();
+
+            if (visited[currentIndex]) { // Skip if node is already visited
+                continue;
+            }
+
+            visited[currentIndex] = true;
+
+            for (int i = 0; i < nodes.length; i++) {
+                if (adjacencyMatrix[currentIndex][i] != Integer.MAX_VALUE && !visited[nodes[i].getIndex()]) {
+                    int weight = adjacencyMatrix[currentIndex][i];
+
+                    if (weight < nodes[i].getCurrMinWeight()) {
+                        Node newNode = new Node(nodes[i].getIdentifier(), nodes[i].getIndex(), weight);
+                        parent[i] = currentIndex; // Set current node as parent of adjacent node
+                        pq.add(newNode);
+                    }
+                }
+            }
+        }
+
+        // Build MST matrix based on parent array
+        for (int i = 1; i < nodes.length; i++) {
+            int p = parent[i];
+            if (p != -1) {
+                int weight = adjacencyMatrix[p][i];
+                mstMatrix[p][i] = weight;
+                mstMatrix[i][p] = weight; // For undirected graphs
+            }
+        }
+
+        return mstMatrix;
+    }
+
+    /**
+     * Node class to represent a node in the graph
+     * Note: In our Node class, we do not allow the currMinWeight to be updated after initialization to prevent any
+     * reference issues in the PriorityQueue.
+     */
+    static class Node {
+        private final int currMinWeight; // Current minimum weight to get to this node
+        private int index; // Index of this node in the adjacency matrix
+        private final String identifier;
+
+        /**
+         * Constructor for Node
+         * @param identifier
+         * @param index
+         * @param currMinWeight
+         */
+        public Node(String identifier, int index, int currMinWeight) {
+            this.identifier = identifier;
+            this.index = index;
+            this.currMinWeight = currMinWeight;
+        }
+
+        /**
+         * Constructor for Node with default currMinWeight
+         * @param identifier
+         * @param index
+         */
+        public Node(String identifier, int index) {
+            this.identifier = identifier;
+            this.index = index;
+            this.currMinWeight = Integer.MAX_VALUE;
+        }
+
+        /**
+         * Getter and setter for currMinWeight
+         */
+        public int getCurrMinWeight() {
+            return currMinWeight;
+        }
+
+        /**
+         * Getter for identifier
+         * @return identifier
+         */
+        public String getIdentifier() {
+            return identifier;
+        }
+
+        public int getIndex() {
+            return index;
+        }
+
+        @Override
+        public String toString() {
+            return "Node{" + "identifier='" + identifier + '\'' + ", index=" + index + '}';
+        }
+    }
+}
+

src/test/java/algorithms/minimumSpanningTree/kruskal/KruskalTest.java

@@ -0,0 +1,84 @@
+package algorithms.minimumSpanningTree.kruskal;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+public class KruskalTest {
+    @Test
+    public void test_simpleGraph() {
+        // Graph setup (Adjacency Matrix)
+        //     B
+        //    / \
+        //   1   1
+        //  /     \
+        // A - 1 - C
+        int[][] adjacencyMatrix = {
+            {0, 1, 1}, // A: A-B, A-C
+            {1, 0, 1}, // B: B-A, B-C
+            {1, 1, 0}  // C: C-A, C-B
+        };
+
+        Kruskal.Node[] nodes = {
+            new Kruskal.Node("A", 0),
+            new Kruskal.Node("B", 1),
+            new Kruskal.Node("C", 2)
+        };
+
+        // Run Kruskal's algorithm
+        int[][] actualMST = Kruskal.getKruskalMST(nodes, adjacencyMatrix);
+
+        // Expected MST
+        // A -1- B -1- C
+        int[][] expectedMST = {
+            {0, 1, 1}, // A: A-B, A-C
+            {1, 0, Integer.MAX_VALUE}, // B: B-A
+            {1, Integer.MAX_VALUE, 0}  // C: C-A
+        };
+
+        // Assertion
+        assertArrayEquals(expectedMST, actualMST);
+    }
+
+    @Test
+    public void test_complexGraph() {
+        // Graph setup
+        //    A
+        //  / | \
+        // 1  4  3
+        ///   |   \
+        //B --3-- D
+        // \  |  /
+        //  2 4 1
+        //   \|/
+        //    C
+        int[][] adjacencyMatrix = {
+                {0, 1, 4, 3}, // A: A-B, A-C, A-D
+                {1, 0, 2, 3}, // B: B-A, B-C, B-D
+                {4, 2, 0, 1}, // C: C-A, C-B, C-D
+                {3, 3, 1, 0}  // D: D-A, D-B, D-C
+        };
+
+        Kruskal.Node[] nodes = {
+            new Kruskal.Node("A", 0),
+            new Kruskal.Node("B", 1),
+            new Kruskal.Node("C", 2),
+            new Kruskal.Node("D", 3)
+        };
+
+        // Run Prim's algorithm
+        int[][] actualMST = Kruskal.getKruskalMST(nodes, adjacencyMatrix);
+
+        // Expected MST
+        // Based on the graph, assuming the MST is correctly computed
+        int[][] expectedMST = {
+            {0, 1, Integer.MAX_VALUE, Integer.MAX_VALUE}, // A: A-B
+            {1, 0, 2, Integer.MAX_VALUE}, // B: B-A, B-C
+            {Integer.MAX_VALUE, 2, 0, 1}, // C: C-B, C-D
+            {Integer.MAX_VALUE, Integer.MAX_VALUE, 1, 0}  // D: D-C
+        };
+
+        // Assertion
+        assertArrayEquals(expectedMST, actualMST);
+    }
+}