PRIM'S

ALGORITHM
CONTENTS
01 MINIMUM SPANNING TREE

02 PRIM'S ALGORITHM

03 IMPLEMENTATION

04 COMPLEXITY
MINIMUM SPANNING
TREE (MST)
 MINIMUM SPANNING TREE :

Minimum spanning tree is subset of edges of a connected, weighted undirected graph that connects all vertices together and bears the
minimum possible total edge weight
Minimum Spanning Tree is also called Minimum Weight Spanning Tree
MST is a tree so it does not contain any cycle
PRIM'S ALGORITHM
 PRIM'S ALGORITHM :

proc primMST(G, r) // G = (V, E)

resultSet  {} //empty set
vertices  G.V
foreach v ϵ vertices do
v.key  ∞
v.parent  null
r.key  0
while vertices != {} do
u  findMinByKey(vertices)
vertices  vertices – u
if u.parent != null then
resultSet = resultSet U (u, u.parent)
endif
foreach v ϵ G.adjacentList(u) do
if v ϵ vertices AND (u,v).weight < v.key then
v.parent  u
v.key  (u,v).weight
end if
return resultSet
IMPLEMENTATION
PRIM'S ALGORITHM :

resultSet = {}
PRIM'S ALGORITHM :

resultSet = {}
vertices = {A, B, C, D, E, F}
PRIM'S ALGORITHM :

resultSet = {}
vertices = {A, B, C, D, E, F}
A(∞, null), B(∞, null), C(∞, null),
D(∞, null), E(∞, null), F(∞, null)}
PRIM'S ALGORITHM :

resultSet = {}
vertices = {A, B, C, D, E, F}
A(0, null), B(∞, null), C(∞, null),
D(∞, null), E(∞, null), F(∞, null)
PRIM'S ALGORITHM :

resultSet = {}
vertices = {B, C, D, E, F}
A(0, null), B(∞, null), C(∞, null),
D(∞, null), E(∞, null), F(∞, null)
u=A
If condition = false
PRIM'S ALGORITHM :

resultSet = {}
vertices = {B, C, D, E, F}
A(0, null), B(3, A), C(∞, null),
D(∞, null), E(∞, null), F(∞, null)
u=A
If condition = false
G.adjacentList = {B, D}
v=B
2nd if condition = true
PRIM'S ALGORITHM :

resultSet = {}
vertices = {B, C, D, E, F}
A(0, null), B(3, A), C(∞, null),
D(2, A), E(∞, null), F(∞, null)
u=A
If condition = false
G.adjacentList = {B, D}
v=D
2nd if condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(∞, null),
D(2, A), E(∞, null), F(∞, null)
u=D
If condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(∞, null),
D(2, A), E(∞, null), F(∞, null)
u=D
1st If condition = true
u.adjacentList={A, B, C, E, F}
v=A
2nd if condition is false
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(∞, null),
D(2, A), E(∞, null), F(∞, null)
u=D
1st If condition = true
u.adjacentList={A, B, C, E, F}
v=B
2nd if condition is false
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(3, D),
D(2, A), E(∞, null), F(∞, null)
u=D
1st If condition = true
u.adjacentList={A, B, C, E, F}
v=C
2nd if condition is true
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(3, D),
D(2, A), E(4, D), F(∞, null)
u=D
1st If condition = true
u.adjacentList={A, B, C, E, F}
v=E
2nd if condition is true
 PRIM'S ALGORITHM :

resultSet = {(A,D)}
vertices = {B, C, E, F}
A(0, null), B(3, A), C(3, D),
D(2, A), E(4, D), F(1, D)
u=D
1st If condition = true
u.adjacentList={A, B, C, E, F}
v=F
2nd if condition is true
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F)}

vertices = {B, C, E}
A(0, null), B(3, A), C(3, D),
D(2, A), E(4, D), F(1, D)
u=F
1st If condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F)}

vertices = {B, C, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=F
1st If condition = true
v=C
2nd condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F)}

vertices = {B, C, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=F
1st If condition = true
v=E
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F)}

vertices = {B, C, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=F
1st If condition = true
v=D
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C)}

vertices = {B, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=C
1st If condition = true
v=B
PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C)}

vertices = {B, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=C
1st If condition = true
v=B
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C)}

vertices = {B, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=C
1st If condition = true
v=F
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C)}

vertices = {B, E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=C
1st If condition = true
v=D
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B)}

vertices = {E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=B
1st If condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B)}

vertices = {E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=B
1st If condition = true
v=A
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B)}

vertices = {E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=B
1st If condition = true
v=D
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B)}

vertices = {E}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=B
1st If condition = true
v=C
2nd condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B), (D,E)}

vertices = {}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=E
1st If condition = true
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B), (D,E)}

vertices = {}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=E
1st If condition = true
v =D
2nd if condition = false
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B), (D,E)}

vertices = {}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
u=E
1st If condition = true
v =F
2nd if condition = false
PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B), (D,E)}

vertices = {}
A(0, null), B(3, A), C(2, F),
D(2, A), E(4, D), F(1, D)
1st If condition = FALSE
 PRIM'S ALGORITHM :

resultSet = {(A,D), (D,F), (F,C), (A,B), (D,E)}

COMPLEXITY
 COMPLEXITY :

it uses a single array of integers to define a sub-graph of a graph. The time complexity is O(VlogV + ElogV) = O(ElogV), making it the same
as Kruskal's algorithm. However, Prim's algorithm can be improved using Fibonacci Heaps (cf Cormen) to O(E + logV)