Kruskal's algorithm

Kruskal’s Algorithm for Computing MSTs
Presented by: Raj Kumar Ranabhat
M.E in Computer Engineering(I/I)
Kathmandu University

Tree
A tree is a graph with the following properties:
• The graph is connected (can go from anywhere to anywhere)
• There are no cycles(acyclic)
Graphs that are not treesTree

Minimum Spanning Tree (MST)
3
• T is a tree (i.e., it is acyclic)
• T covers all the vertices V
• contains |V| - 1 edges
• T has minimum total weight
• A single graph can have many different spanning trees.
Let G=(V,E) be an undirected connected graph.
A sub graph T=(V,E’) of G is a spanning tree of G if :-

Connected undirected graph Spanning Tree

Kruskal’s Algorithm
• It is a algorithm used to find a minimum cost spanning tree for connected weighted
undirected graph
• This algorithm first appeared in Proceedings of the American Mathematical Society
in 1956, and was written by Joseph Kruskal
A B
C D
A B
C D
Connected Weighted
1
5
3
4 26
1
3
2
• It's a spanning tree because it connects all vertices
without loops.
• Tree weight is minimum of all possibilities hence
minimum cost spanning tree

Disjoint Sets
6
• A disjoint set is a data structure which keeps track of all elements that are separated by
a number of disjoint (not connected) subsets.
• It supports three useful operations
• MAKE-SET(x): Make a new set with a single element x
• UNION (S1,S2): Merge the set S1 and set S2
• FIND-SET(x): Find the set containing the element x

Disjoint Sets
7
1 2 3
MAKE-SET(1), MAKE-SET(2), MAKE-
SET(3) creates new set S1,S2,S3
S1 S2 S3

Disjoint Sets
8
1 2
UNION (1,2) merge set S1 and set S2
to create set S4
1 2 3
S1 S2 S3 S4
MAKE-SET(1), MAKE-SET(2), MAKE-
SET(3) creates new set S1,S2,S3

Disjoint Sets
9
a number of disjoint (not connected) subsets
1 2
UNION (1,2) merge set S1 and set S2
to create set S4
1 2 3
S1 S2 S3 S4
FIND-SET(2) returns set S4
1 2
S4
MAKE-SET(1), MAKE-
SET(2), MAKE-SET(3) creates
new set S1,S2,S3

KRUSKAL(V,E):
A = ∅
foreach 𝑣∈ V:
MAKE-SET(𝑣)
Sort E by weight increasingly
foreach (𝑣1,𝑣2) ∈ E:
if FIND-SET(𝑣1) ≠ FIND-SET(𝑣2):
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
Remove edge (𝑣1,𝑣2)
return A
Kruskal’s Algorithm

A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
AB 4
BC 6
CD 3
DE 2
EF 4
AF 2
BF 5
CF 1
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
AB 4
BC 6
CD 3
DE 2
EF 4
AF 2
BF 5
CF 1
A ={ }

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
AB 4
BC 6
CD 3
DE 2
EF 4
AF 2
BF 5
CF 1
A B C
A ={ }
F DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A B C
F DE
A ={ }

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
A ={ }
A B C
F DE
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A ={ }
A B C
F DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A ={(C,F)}
A B C
F DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
C
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A ={(C,F)}
A B
DE
C,F

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
F
D
E
4
6 3
2
4
2
5 1
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
C
A ={(C,F),(A,F)}
A B
DE
C,F

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A
B
F
D
E
4
6 3
2
4
2
5 1
A,C,F
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
C
A ={(C,F),(A,F)}
B
DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
B D
E
4
6 3
2
4
2
5 1
A
F
C
A ={(C,F),(A,F)}
A,C,FB
DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
B
4
6 3
2
4
2
5 1
D
EA
F
C
A ={(C,F),(A,F),(D,E)}
A,C,FB
DE

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
D,E
B
4
6 3
2
4
2
5 1
D
EA
F
C
A ={(C,F),(A,F),(D,E)}
A,C,FB

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
B
4
6 3
2
4
2
5 1
A
C
F
D
E
A ={(C,F),(A,F),(D,E)}
D,E
A,C,FB

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
B
4
6 3
2
4
2
5 1
A
C
F
D
E
A ={(C,F),(A,F),(D,E),
(C,D)}
D,E
A,C,FB

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A,C,D,E,F
B
4
6 3
2
4
2
5 1
A
C
F
D
E
A ={(C,F),(A,F),(D,E),
(C,D)}
B

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
B
4
6 3
2
4
2
5 1
A
C
F
D
E
A ={(C,F),(A,F),(D,E),
(C,D)}
A,C,D,E,FB

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
6 3
2
4
2
5 1
B
A
C
F
D
E
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,C,D,E,FB

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
6 3
2
4
2
5 1
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
6 3
2
4
2
5 1
A
B
C
F
D
E
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
F
E
4
6 3
2
4
2
5 1
Is in a same set.
A
B
C
D
It is cyclic
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
6 3
2
2
5 1
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F
4

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
6 3
2
2
5 1
F
EA
B
C
DKRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
6 3
2
2
5 1
Is in a same set.
It is cyclic
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
6 3
2
2
1
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F
5

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
6 3
2
2
1
F
EA
B
C
DKRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
6 3
2
2
1
It is cyclic
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
Is in a same set.
A,B,C,D,E,F

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
A
B
C
F
D
E
4
3
2
2
1
KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}
A,B,C,D,E,F
6

Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
3
2
2
1
F
EA
B
C
DKRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
A ={(C,F),(A,F),(D,E),
(C,D),(A,B)}

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Edges Weight
CF 1
AF 2
DE 2
CD 3
AB 4
FE 4
BF 5
BC 6
4
3
2
2
1
Total Weight :- 1 + 2 + 2 + 3 + 4
= 12
F
EA
B
C
D
A ={(C,F),(A,F),(D,E),(C,D),(A,B)}

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Time Complexity
O(1)
O(V)
O(E log E)
O(E log V)

KRUSKAL(V,E):
A = ∅
foreach 𝑣 ∈ V:
MAKE-SET(𝑣)
A = A ∪ {(𝑣1,𝑣2)}
UNION(𝑣1,𝑣2)
else
return A
Time Complexity
O(1)
O(V)
O(E log E)
Time Complexity = O(1)+ O(V)+O(E log E)+O(E log V)
= O(E log E) + O(E log V)
Since, |E| ≤ |V|2 ⇒log |E| = O(2 log V) = O(log V).
= O(E log V) + O(E log V)
= O(E log V)
O(E log V)

Real-life applications of Kruskal's algorithm
• Landing Cables
• TV Network
• Tour Operations
• Computer networking
• Study of Molecular bonds in Chemistry
• Routing Algorithms

Problem: Laying Telephone Wire
Central office

Wiring: Naïve Approach
Central office
Expensive!

Wiring: Better Approach
Central office
Minimize the total length of wire connecting the customers

Kruskal's algorithm

More Related Content

What's hot (20)

Similar to Kruskal's algorithm (20)

More from Raj Kumar Ranabhat (9)

Recently uploaded (20)

Kruskal's algorithm