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

• Difficulty Level : Medium
• Last Updated : 08 Jul, 2021

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 */`

## Javascript

 ``

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++

My Personal Notes arrow_drop_up
Recommended Articles
Page :