Understanding Kruskal's algorithm

    In this tutorial, you will learn how the Kruskal algorithm works. In addition, you will find examples in C language.
    The Kruskal algorithm is a minimum spanning tree algorithm that takes a graph as input and finds a subset of the edges of the graph. The subset

• Form a tree with every vertex
• Has the smallest sum of weights among all the trees that can be formed from the graph

How the Kruskal algorithm works

    It belongs to a class of algorithms called greedy algorithms. This algorithm hopes to find the global optimum by looking for the local optimum.
    We start with the edge with the lowest weight and keep adding edges until we reach the goal.
    The steps to implement Kruskal's algorithm are as follows:

1. Sort all edges by weight from low to high
2. Take the edge with the smallest weight and add it to the spanning tree. If adding an edge causes a loop, this edge is not used.
3. Continue adding edges until all vertices are reached.

Example of Kruskal algorithm

    Starting from the weighted graph,

    select the edge with the smallest weight. If there are multiple edges,

    select the next shortest edge and add it.

    Select the next shortest edge that does not create a loop and add it. Select the next shortest edge that does not create a loop and add

    it. Add it and

    repeat the above steps until a spanning tree is generated

Kruskal algorithm pseudo code

    Any minimum spanning tree algorithm revolves around whether adding edges creates a loop.
    The most common method is an algorithm called Union-Find. The Union-Find algorithm divides the vertices into clusters and checks whether two vertices belong to the same cluster, so as to determine whether adding an edge creates a loop.

KRUSKAL(G):
A = ∅
For each vertex v ∈ G.V:
    MAKE-SET(v)
For each edge (u, v) ∈ G.E ordered by increasing order by weight(u, v):
    if FIND-SET(u) ≠ FIND-SET(v):       
    A = A ∪ {
    
    (u, v)}
    UNION(u, v)
return A

C example

// Kruskal's algorithm in C

#include <stdio.h>

#define MAX 30

typedef struct edge {
    
    
  int u, v, w;
} edge;

typedef struct edge_list {
    
    
  edge data[MAX];
  int n;
} edge_list;

edge_list elist;

int Graph[MAX][MAX], n;
edge_list spanlist;

void kruskalAlgo();
int find(int belongs[], int vertexno);
void applyUnion(int belongs[], int c1, int c2);
void sort();
void print();

// Applying Krushkal Algo
void kruskalAlgo() {
    
    
  int belongs[MAX], i, j, cno1, cno2;
  elist.n = 0;

  for (i = 1; i < n; i++)
    for (j = 0; j < i; j++) {
    
    
      if (Graph[i][j] != 0) {
    
    
        elist.data[elist.n].u = i;
        elist.data[elist.n].v = j;
        elist.data[elist.n].w = Graph[i][j];
        elist.n++;
      }
    }

  sort();

  for (i = 0; i < n; i++)
    belongs[i] = i;

  spanlist.n = 0;

  for (i = 0; i < elist.n; i++) {
    
    
    cno1 = find(belongs, elist.data[i].u);
    cno2 = find(belongs, elist.data[i].v);

    if (cno1 != cno2) {
    
    
      spanlist.data[spanlist.n] = elist.data[i];
      spanlist.n = spanlist.n + 1;
      applyUnion(belongs, cno1, cno2);
    }
  }
}

int find(int belongs[], int vertexno) {
    
    
  return (belongs[vertexno]);
}

void applyUnion(int belongs[], int c1, int c2) {
    
    
  int i;

  for (i = 0; i < n; i++)
    if (belongs[i] == c2)
      belongs[i] = c1;
}

// Sorting algo
void sort() {
    
    
  int i, j;
  edge temp;

  for (i = 1; i < elist.n; i++)
    for (j = 0; j < elist.n - 1; j++)
      if (elist.data[j].w > elist.data[j + 1].w) {
    
    
        temp = elist.data[j];
        elist.data[j] = elist.data[j + 1];
        elist.data[j + 1] = temp;
      }
}

// Printing the result
void print() {
    
    
  int i, cost = 0;

  for (i = 0; i < spanlist.n; i++) {
    
    
    printf("\n%d - %d : %d", spanlist.data[i].u, spanlist.data[i].v, spanlist.data[i].w);
    cost = cost + spanlist.data[i].w;
  }

  printf("\nSpanning tree cost: %d", cost);
}

int main() {
    
    
  int i, j, total_cost;

  n = 6;

  Graph[0][0] = 0;
  Graph[0][1] = 4;
  Graph[0][2] = 4;
  Graph[0][3] = 0;
  Graph[0][4] = 0;
  Graph[0][5] = 0;
  Graph[0][6] = 0;

  Graph[1][0] = 4;
  Graph[1][1] = 0;
  Graph[1][2] = 2;
  Graph[1][3] = 0;
  Graph[1][4] = 0;
  Graph[1][5] = 0;
  Graph[1][6] = 0;

  Graph[2][0] = 4;
  Graph[2][1] = 2;
  Graph[2][2] = 0;
  Graph[2][3] = 3;
  Graph[2][4] = 4;
  Graph[2][5] = 0;
  Graph[2][6] = 0;

  Graph[3][0] = 0;
  Graph[3][1] = 0;
  Graph[3][2] = 3;
  Graph[3][3] = 0;
  Graph[3][4] = 3;
  Graph[3][5] = 0;
  Graph[3][6] = 0;

  Graph[4][0] = 0;
  Graph[4][1] = 0;
  Graph[4][2] = 4;
  Graph[4][3] = 3;
  Graph[4][4] = 0;
  Graph[4][5] = 0;
  Graph[4][6] = 0;

  Graph[5][0] = 0;
  Graph[5][1] = 0;
  Graph[5][2] = 2;
  Graph[5][3] = 0;
  Graph[5][4] = 3;
  Graph[5][5] = 0;
  Graph[5][6] = 0;

  kruskalAlgo();
  print();
}

Kruskal algorithm vs Prim algorithm

    Prim's algorithm is another popular minimum spanning tree algorithm, which uses different logic to find the MST (minimum spanning tree) of the graph. Prim's algorithm does not start from an edge, but from a vertex, and continues to add edges with the smallest weight that are not in the tree until all vertices are covered.

The complexity of Kruskal's algorithm

    The time complexity of Kruskal's algorithm is: O(E log E).

Application of Kruskal Algorithm

• Lay out electrical wiring
• For computer network (LAN connection)

Reference documents

[1]Parewa Labs Pvt. Ltd.Kruskal’s Algorithm[EB/OL].https://www.programiz.com/dsa/kruskal-algorithm,2020-01-01.