# Kruskal’s Algorithm (Simple Implementation for Adjacency Matrix)

Below are the steps for finding MST using Kruskal’s algorithm

1. Sort all the edges in non-decreasing order of their weight.
2. Pick the smallest edge. Check if it forms a cycle with the spanning tree formed so far. If cycle is not formed, include this edge. Else, discard it.
3. Repeat step#2 until there are (V-1) edges in the spanning tree.

We have discussed one implementation of Kruskal’s algorithm in previous post. In this post, a simpler implementation for adjacency matrix is discussed.

## C++

 `// Simple C++ implementation for Kruskal's ` `// algorithm ` `#include ` `using` `namespace` `std; ` ` `  `#define V 5 ` `int` `parent[V]; ` ` `  `// Find set of vertex i ` `int` `find(``int` `i) ` `{ ` `    ``while` `(parent[i] != i) ` `        ``i = parent[i]; ` `    ``return` `i; ` `} ` ` `  `// Does union of i and j. It returns ` `// false if i and j are already in same ` `// set. ` `void` `union1(``int` `i, ``int` `j) ` `{ ` `    ``int` `a = find(i); ` `    ``int` `b = find(j); ` `    ``parent[a] = b; ` `} ` ` `  `// Finds MST using Kruskal's algorithm ` `void` `kruskalMST(``int` `cost[][V]) ` `{ ` `    ``int` `mincost = 0; ``// Cost of min MST. ` ` `  `    ``// Initialize sets of disjoint sets. ` `    ``for` `(``int` `i = 0; i < V; i++) ` `        ``parent[i] = i; ` ` `  `    ``// Include minimum weight edges one by one ` `    ``int` `edge_count = 0; ` `    ``while` `(edge_count < V - 1) { ` `        ``int` `min = INT_MAX, a = -1, b = -1; ` `        ``for` `(``int` `i = 0; i < V; i++) { ` `            ``for` `(``int` `j = 0; j < V; j++) { ` `                ``if` `(find(i) != find(j) && cost[i][j] < min) { ` `                    ``min = cost[i][j]; ` `                    ``a = i; ` `                    ``b = j; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``union1(a, b); ` `        ``printf``(``"Edge %d:(%d, %d) cost:%d \n"``, ` `               ``edge_count++, a, b, min); ` `        ``mincost += min; ` `    ``} ` `    ``printf``(``"\n Minimum cost= %d \n"``, mincost); ` `} ` ` `  `// driver program to test above function ` `int` `main() ` `{ ` `    ``/* Let us create the following graph ` `          ``2    3 ` `      ``(0)--(1)--(2) ` `       ``|   / \   | ` `      ``6| 8/   \5 |7 ` `       ``| /     \ | ` `      ``(3)-------(4) ` `            ``9          */` `    ``int` `cost[][V] = { ` `        ``{ INT_MAX, 2, INT_MAX, 6, INT_MAX }, ` `        ``{ 2, INT_MAX, 3, 8, 5 }, ` `        ``{ INT_MAX, 3, INT_MAX, INT_MAX, 7 }, ` `        ``{ 6, 8, INT_MAX, INT_MAX, 9 }, ` `        ``{ INT_MAX, 5, 7, 9, INT_MAX }, ` `    ``}; ` ` `  `    ``// Print the solution ` `    ``kruskalMST(cost); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Simple Java implementation for Kruskal's ` `// algorithm ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `static` `int` `V = ``5``; ` `static` `int``[] parent = ``new` `int``[V]; ` `static` `int` `INF = Integer.MAX_VALUE; ` ` `  `// Find set of vertex i ` `static` `int` `find(``int` `i) ` `{ ` `    ``while` `(parent[i] != i) ` `        ``i = parent[i]; ` `    ``return` `i; ` `} ` ` `  `// Does union of i and j. It returns ` `// false if i and j are already in same ` `// set. ` `static` `void` `union1(``int` `i, ``int` `j) ` `{ ` `    ``int` `a = find(i); ` `    ``int` `b = find(j); ` `    ``parent[a] = b; ` `} ` ` `  `// Finds MST using Kruskal's algorithm ` `static` `void` `kruskalMST(``int` `cost[][]) ` `{ ` `    ``int` `mincost = ``0``; ``// Cost of min MST. ` ` `  `    ``// Initialize sets of disjoint sets. ` `    ``for` `(``int` `i = ``0``; i < V; i++) ` `        ``parent[i] = i; ` ` `  `    ``// Include minimum weight edges one by one ` `    ``int` `edge_count = ``0``; ` `    ``while` `(edge_count < V - ``1``) ` `    ``{ ` `        ``int` `min = INF, a = -``1``, b = -``1``; ` `        ``for` `(``int` `i = ``0``; i < V; i++) ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < V; j++)  ` `            ``{ ` `                ``if` `(find(i) != find(j) && cost[i][j] < min)  ` `                ``{ ` `                    ``min = cost[i][j]; ` `                    ``a = i; ` `                    ``b = j; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``union1(a, b); ` `        ``System.out.printf(``"Edge %d:(%d, %d) cost:%d \n"``, ` `            ``edge_count++, a, b, min); ` `        ``mincost += min; ` `    ``} ` `    ``System.out.printf(``"\n Minimum cost= %d \n"``, mincost); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `/* Let us create the following graph ` `        ``2 3 ` `    ``(0)--(1)--(2) ` `    ``| / \ | ` `    ``6| 8/ \5 |7 ` `    ``| /     \ | ` `    ``(3)-------(4) ` `            ``9         */` `    ``int` `cost[][] = { ` `        ``{ INF, ``2``, INF, ``6``, INF }, ` `        ``{ ``2``, INF, ``3``, ``8``, ``5` `}, ` `        ``{ INF, ``3``, INF, INF, ``7` `}, ` `        ``{ ``6``, ``8``, INF, INF, ``9` `}, ` `        ``{ INF, ``5``, ``7``, ``9``, INF }, ` `    ``}; ` ` `  `    ``// Print the solution ` `    ``kruskalMST(cost); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

## Python3

 `# Python implementation for Kruskal's ` `# algorithm ` ` `  `# Find set of vertex i ` `def` `find(i): ` `    ``while` `parent[i] !``=` `i: ` `        ``i ``=` `parent[i] ` `    ``return` `i ` ` `  `# Does union of i and j. It returns ` `# false if i and j are already in same  ` `# set.  ` `def` `union(i, j): ` `    ``a ``=` `find(i) ` `    ``b ``=` `find(j) ` `    ``parent[a] ``=` `b ` ` `  `# Finds MST using Kruskal's algorithm  ` `def` `kruskalMST(cost): ` `    ``mincost ``=` `0` `# Cost of min MST ` ` `  `    ``# Initialize sets of disjoint sets ` `    ``for` `i ``in` `range``(V): ` `        ``parent[i] ``=` `i ` ` `  `    ``# Include minimum weight edges one by one  ` `    ``edge_count ``=` `0` `    ``while` `edge_count < V ``-` `1``: ` `        ``min` `=` `INF ` `        ``a ``=` `-``1` `        ``b ``=` `-``1` `        ``for` `i ``in` `range``(V): ` `            ``for` `j ``in` `range``(V): ` `                ``if` `find(i) !``=` `find(j) ``and` `cost[i][j] < ``min``: ` `                    ``min` `=` `cost[i][j] ` `                    ``a ``=` `i ` `                    ``b ``=` `j ` `        ``union(a, b) ` `        ``print``(``'Edge {}:({}, {}) cost:{}'``.``format``(edge_count, a, b, ``min``)) ` `        ``edge_count ``+``=` `1` `        ``mincost ``+``=` `min` ` `  `    ``print``(``"Minimum cost= {}"``.``format``(mincost)) ` ` `  ` `  `# Driver code  ` `# Let us create the following graph  ` `#         2 3  ` `#     (0)--(1)--(2)  ` `#     | / \ |  ` `#     6| 8/ \5 |7  ` `#     | /     \ |  ` `#     (3)-------(4)  ` `#         9 ` ` `  `V ``=` `5` `parent ``=` `[i ``for` `i ``in` `range``(V)] ` `INF ``=` `float``(``'inf'``) ` `cost ``=` `[[INF, ``2``, INF, ``6``, INF], ` `        ``[``2``, INF, ``3``, ``8``, ``5``], ` `        ``[INF, ``3``, INF, INF, ``7``], ` `        ``[``6``, ``8``, INF, INF, ``9``], ` `        ``[INF, ``5``, ``7``, ``9``, INF]] ` ` `  `# Print the solution  ` `kruskalMST(cost) ` ` `  `# This code is contributed by ng24_7 `

## C#

 `// Simple C# implementation for Kruskal's ` `// algorithm ` `using` `System;      ` ` `  `class` `GFG  ` `{ ` ` `  `static` `int` `V = 5; ` `static` `int``[] parent = ``new` `int``[V]; ` `static` `int` `INF = ``int``.MaxValue; ` ` `  `// Find set of vertex i ` `static` `int` `find(``int` `i) ` `{ ` `    ``while` `(parent[i] != i) ` `        ``i = parent[i]; ` `    ``return` `i; ` `} ` ` `  `// Does union of i and j. It returns ` `// false if i and j are already in same ` `// set. ` `static` `void` `union1(``int` `i, ``int` `j) ` `{ ` `    ``int` `a = find(i); ` `    ``int` `b = find(j); ` `    ``parent[a] = b; ` `} ` ` `  `// Finds MST using Kruskal's algorithm ` `static` `void` `kruskalMST(``int` `[,]cost) ` `{ ` `    ``int` `mincost = 0; ``// Cost of min MST. ` ` `  `    ``// Initialize sets of disjoint sets. ` `    ``for` `(``int` `i = 0; i < V; i++) ` `        ``parent[i] = i; ` ` `  `    ``// Include minimum weight edges one by one ` `    ``int` `edge_count = 0; ` `    ``while` `(edge_count < V - 1) ` `    ``{ ` `        ``int` `min = INF, a = -1, b = -1; ` `        ``for` `(``int` `i = 0; i < V; i++) ` `        ``{ ` `            ``for` `(``int` `j = 0; j < V; j++)  ` `            ``{ ` `                ``if` `(find(i) != find(j) && cost[i, j] < min)  ` `                ``{ ` `                    ``min = cost[i, j]; ` `                    ``a = i; ` `                    ``b = j; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``union1(a, b); ` `        ``Console.Write(``"Edge {0}:({1}, {2}) cost:{3} \n"``, ` `            ``edge_count++, a, b, min); ` `        ``mincost += min; ` `    ``} ` `    ``Console.Write(``"\n Minimum cost= {0} \n"``, mincost); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `/* Let us create the following graph ` `        ``2 3 ` `    ``(0)--(1)--(2) ` `    ``| / \ | ` `    ``6| 8/ \5 |7 ` `    ``| /     \ | ` `    ``(3)-------(4) ` `            ``9         */` `    ``int` `[,]cost = { ` `        ``{ INF, 2, INF, 6, INF }, ` `        ``{ 2, INF, 3, 8, 5 }, ` `        ``{ INF, 3, INF, INF, 7 }, ` `        ``{ 6, 8, INF, INF, 9 }, ` `        ``{ INF, 5, 7, 9, INF }, ` `    ``}; ` ` `  `    ``// Print the solution ` `    ``kruskalMST(cost); ` `} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

Output:

```Edge 0:(0, 1) cost:2
Edge 1:(1, 2) cost:3
Edge 2:(1, 4) cost:5
Edge 3:(0, 3) cost:6

Minimum cost= 16
```

Note that the above solution is not efficient. The idea is to provide a simple implementation for adjacency matrix representations. Please see below for efficient implementations.
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Kruskal’s Minimum Spanning Tree using STL in C++

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Android Developer Big Data Analyst Machine Learning Enthusiast and Algorithm Designer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.