New Commit

Author: coder-mayank22

Kruskal's_algo.c

@@ -0,0 +1,98 @@
+#include <stdio.h>  
+#include <stdlib.h>  
+  
+#define MAX_EDGES 1000  
+  
+typedef struct Edge {  
+    int src, dest, weight;  
+} Edge;  
+  
+typedef struct Graph {  
+    int V, E;  
+    Edge edges[MAX_EDGES];  
+} Graph;  
+  
+typedef struct Subset {  
+    int parent, rank;  
+} Subset;  
+  
+Graph* createGraph(int V, int E) {  
+    Graph* graph = (Graph*) malloc(sizeof(Graph));  
+    graph->V = V;  
+    graph->E = E;  
+    return graph;  
+}  
+  
+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++;  
+    }  
+}  
+  
+int compare(const void* a, const void* b) {  
+    Edge* a_edge = (Edge*) a;  
+    Edge* b_edge = (Edge*) b;  
+    return a_edge->weight - b_edge->weight;  
+}  
+  
+void kruskalMST(Graph* graph) {  
+    Edge mst[graph->V];  
+    int e = 0, i = 0;  
+  
+    qsort(graph->edges, graph->E, sizeof(Edge), compare);  
+  
+    Subset* subsets = (Subset*) malloc(graph->V * sizeof(Subset));  
+    for (int v = 0; v < graph->V; ++v) {  
+        subsets[v].parent = v;  
+        subsets[v].rank = 0;  
+    }  
+  
+    while (e < graph->V - 1 && i < graph->E) {  
+        Edge next_edge = graph->edges[i++];  
+  
+        int x = find(subsets, next_edge.src);  
+        int y = find(subsets, next_edge.dest);  
+  
+        if (x != y) {  
+            mst[e++] = next_edge;  
+            Union(subsets, x, y);  
+        }  
+    }  
+  
+    printf("Minimum Spanning Tree:\n");  
+    for (i = 0; i < e; ++i) {  
+        printf("(%d, %d) -> %d\n", mst[i].src, mst[i].dest, mst[i].weight);  
+    }  
+}  
+  
+int main() {  
+    int V, E;  
+    printf("Enter number of vertices and edges: ");  
+    scanf("%d %d", &V, &E);  
+  
+    Graph* graph = createGraph(V, E);  
+  
+    printf("Enter edges and their weights:\n");  
+    for (int i = 0; i < E; ++i) {  
+        scanf("%d %d %d", &graph->edges[i].src, &graph->edges[i].dest, &graph->edges[i].weight);  
+    }  
+  
+    kruskalMST(graph);  
+  
+    return 0;
+}

Kruskal's_algo.exe

@@ -0,0 +1,84 @@
+#include<stdio.h>
+#include<stdbool.h>
+
+#define INF 9999999
+#define V 5
+
+//The adjacency matrix
+/*int G[V][V] = {
+	{0, 9, 75, 0, 0},
+	{9, 0, 95, 19, 42},
+	{75, 95, 0, 51, 66},
+	{0, 19, 51, 0, 31},
+	{0, 42, 66, 31, 0}};
+*/
+
+void addEdge(int u, int v, int adjMatrix[V][V]){
+	int w;
+	printf("Enter weight of edge between %d and %d : ", u, v);
+	scanf("%d", &w);
+	adjMatrix[u][v] = w;
+	adjMatrix[v][u] = w;
+}
+
+void displayMatrix(int nodes, int adjMatrix[V][V]){
+	int i, j;
+	printf("Adjacency Matrix :\n");
+	for(i=0; i<V; i++){
+		for(j=0; j<V; j++)
+		printf("%d\t",adjMatrix[i][j]);
+		printf("\n");
+	}
+}
+int main(){
+	int i, j, u, v;
+	int sum = 0;
+	static int G[V][V];
+	
+	int no_edge;// number of edges
+	int selected[V];
+    
+	for(i=0; i<V; i++){
+		for(j=0; j<V; j++){
+			addEdge(i, j, G);
+		}
+	}
+	
+	displayMatrix(V, G);
+	
+	memset(selected, false, sizeof(selected));
+	
+	no_edge = 0;
+	selected[0] = true;
+	
+	int x; //row no
+	int y; //col no
+	
+	printf("Edge : Weight\n");
+	
+	while(no_edge < V-1){
+		int min = INF;
+		x = 0;
+		y = 0;
+		
+		for(i=0; i<V; i++){
+			if(selected[i]){
+				for(j=0; j<V;j++){
+					if(!selected[j] && G[i][j]){
+						if(min > G[i][j]){
+							min = G[i][j];
+							x = i;
+							y = j;
+						}
+					}
+				}
+			}
+		}
+		printf("%d - %d : %d\n", x, y, G[x][y]);
+		sum += G[x][y];
+		selected[y] = true;
+		no_edge++;
+	}
+	printf("\nTotal Weight = %d\n", sum);
+	return 0;
+}