Merge pull request #96 from SuramyaRanjan/main

Prim,s and Kruskal's algorithm

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();
+    }
+}

DSA/Graph/PrimsAlgorithm.java

@@ -0,0 +1,61 @@
+import java.util.*;
+
+class PrimsAlgorithm {
+    private static final int V = 5;
+
+    int minKey(int[] key, boolean[] mstSet) {
+        int min = Integer.MAX_VALUE, minIndex = -1;
+        for (int v = 0; v < V; v++) {
+            if (!mstSet[v] && key[v] < min) {
+                min = key[v];
+                minIndex = v;
+            }
+        }
+        return minIndex;
+    }
+
+    void printMST(int[] parent, int[][] graph) {
+        System.out.println("Edge \tWeight");
+        for (int i = 1; i < V; i++) {
+            System.out.println(parent[i] + " - " + i + "\t" + graph[i][parent[i]]);
+        }
+    }
+
+    void primMST(int[][] graph) {
+        int[] parent = new int[V];
+        int[] key = new int[V];
+        boolean[] mstSet = new boolean[V];
+
+        for (int i = 0; i < V; i++) {
+            key[i] = Integer.MAX_VALUE;
+            mstSet[i] = false;
+        }
+
+        key[0] = 0;
+        parent[0] = -1;
+
+        for (int count = 0; count < V - 1; count++) {
+            int u = minKey(key, mstSet);
+            mstSet[u] = true;
+            for (int v = 0; v < V; v++) {
+                if (graph[u][v] != 0 && !mstSet[v] && graph[u][v] < key[v]) {
+                    parent[v] = u;
+                    key[v] = graph[u][v];
+                }
+            }
+        }
+        printMST(parent, graph);
+    }
+
+    public static void main(String[] args) {
+        PrimsAlgorithm prim = new PrimsAlgorithm();
+        int graph[][] = new int[][]{
+            {0, 2, 0, 6, 0},
+            {2, 0, 3, 8, 5},
+            {0, 3, 0, 0, 7},
+            {6, 8, 0, 0, 9},
+            {0, 5, 7, 9, 0}
+        };
+        prim.primMST(graph);
+    }
+}