Prims and kruskal algorithms

Saga Valsalan
www.SagaValsalan.blogspot.in
www.YouTube.com/SagaValsalan
www.Facebook.com/SagaValsalan

Minimum SpanningTrees (MST)
• A minimum spanning tree (MST) or minimum weight
spanning tree is a spanning tree of a connected, undirected
graph.
• It connects all the vertices together with the minimal total
weighting for its edges.
• MST is a tree ,because it is acyclic
• Any undirected graph has a minimum spanning forest, which
is a union of minimum spanning trees for its connected
components.
• If a graph has N vertices then the spanning tree will have N-1
edges

2 19
9
1
5
13
17
25
14
8
21

Prims Algorithm
• Prim's algorithm is a greedy algorithm that finds a
minimum spanning tree for a weighted undirected graph.
• It finds a subset of the edges that forms a tree that
includes every vertex, where the total weight of all the
edges in the tree is minimized.
• The algorithm operates by building this tree one vertex at
a time, from an arbitrary starting vertex, at each step
adding the cheapest possible connection from the tree to
another vertex.

Prims Algorithm
Procedure:
• Initialize the min priority queue Q to contain all the
vertices.
• Set the key of each vertex to ∞ and root’s key is set to
zero
• Set the parent of root to NIL
• If weight of vertex is less than key value of the vertex,
connect the graph.
• Repeat the process till all vertex are used.

MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);
Initialize the min priority queue Q to contain
all the vertices.
Set the key of each vertex to ∞
Set the parent of root to NIL
Root’s key is set to 0
Until queue become null set
Input– Graph, Weight, Root
Set the parent of ‘v’ as ‘u’
Set the key of v = weight of edge
connecting uv
Prims Algorithm

MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
14
10
3
6 4
5
2
9
15
8
Run on example graph
Prims Algorithm

  
  


14
10
3
6 4
5
2
9
15
8
Run on example graph
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

  
0  


14
10
3
6 4
5
2
9
15
8
Pick a start vertex r
r
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

  
0  


14
10
3
6 4
5
2
9
15
8
Black vertices have been removed from Q
u
Prims Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);

  
0  
3

14
10
3
6 4
5
2
9
15
8
Black arrows indicate parent pointers
u
Prims Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);

14  
0  
3

14
10
3
6 4
5
2
9
15
8
u
Prims Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);

14  
0  
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

14  
0 8 
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

10  
0 8 
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

10 2 
0 8 
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

10 2 
0 8 15
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

10 2 9
0 8 15
3

14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

10 2 9
0 8 15
3
4
14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

5 2 9
0 8 15
3
4
14
10
3
6 4
5
2
9
15
8
u
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
Prims Algorithm

MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
p[v] = u;
key[v] = w(u,v);
5 2 9
0 8 15
3
4
3
4
5
2
9
15
8
Prims Algorithm

Kruskals Algorithm
• Kruskal's algorithm is a minimum-spanning-tree
algorithm which finds an edge of the least possible
weight that connects any two trees in the forest.
• It is a greedy algorithm, adding increasing cost arcs
at each step.
• This means it finds a subset of the edges that forms
a tree that includes every vertex, where the total
weight of all the edges in the tree is minimized.
• To visit all nodes, with minimum cost, without cycle
formation

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
Kruskals Algorithm
T-Tree
E-Edge
V-Vertices
v-Vertex
MakeSet(x): S = S U {{x}}
Union(Si, Sj): S = S - {Si, Sj} U {Si U Sj}
FindSet(X): return Si  S such that x  Si

2 19
9
1
5
13
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2 19
9
1?
5
13
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2? 19
9
1
5
13
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2 19
9
1
5?
13
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2 19
9
1
5
13
17
25
14
8?
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2 19
9?
1
5
13
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

2 19
9
1
5
13?
17
25
14
8
21
Run the algorithm:
Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19
9
1
5
13
17
25
14
8
21
Run the algorithm:
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19
9
1
5
13
17
25
14?
8
21
Run the algorithm:
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19
9
1
5
13
17?
25
14
8
21
Run the algorithm:
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19?
9
1
5
13
17
25
14
8
21
Run the algorithm:
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19
9
1
5
13
17
25
14
8
21?
Run the algorithm:
Kruskals Algorithm

Kruskal()
{
T = ;
for each v  V
MakeSet(v);
T = T U {{u,v}};
}
2 19
9
1
5
13
17
25?
14
8
21
Run the algorithm:
Kruskals Algorithm

Prims and kruskal algorithms

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Prims and kruskal algorithms (18)

Recently uploaded (20)

Prims and kruskal algorithms