Open in App
Not now

# Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5

• Difficulty Level : Medium
• Last Updated : 30 Jan, 2023

## Introduction to Prim’s algorithm:

We have discussed Kruskal’s algorithm for Minimum Spanning Tree. Like Kruskal’s algorithm, Prim’s algorithm is also a Greedy algorithm. Prim’s algorithm always starts with a single node and it moves through several adjacent nodes, in order to explore all of the connected edges along the way.

It starts with an empty spanning tree. The idea is to maintain two sets of vertices. The first set contains the vertices already included in the MST, and the other set contains the vertices not yet included. At every step, it considers all the edges that connect the two sets and picks the minimum weight edge from these edges. After picking the edge, it moves the other endpoint of the edge to the set containing MST.

A group of edges that connects two sets of vertices in a graph is called cut in graph theorySo, at every step of Prim’s algorithm, find a cut (of two sets, one contains the vertices already included in MST and the other contains the rest of the vertices), pick the minimum weight edge from the cut, and include this vertex to MST Set (the set that contains already included vertices).

## How does Prim’s Algorithm Work?

The idea behind Prim’s algorithm is simple, a spanning tree means all vertices must be connected. So the two disjoint subsets (discussed above) of vertices must be connected to make a Spanning Tree. And they must be connected with the minimum weight edge to make it a Minimum Spanning Tree.

### Follow the given steps to find MST using Prim’s Algorithm:

• Create a set mstSet that keeps track of vertices already included in MST.
• Assign a key value to all vertices in the input graph. Initialize all key values as INFINITE. Assign the key value as 0 for the first vertex so that it is picked first.
• While mstSet doesn’t include all vertices
• Pick a vertex u which is not there in mstSet and has a minimum key value.
• Include u in the mstSet.
• Update the key value of all adjacent vertices of u. To update the key values, iterate through all adjacent vertices. For every adjacent vertex v, if the weight of edge u-v is less than the previous key value of v, update the key value as the weight of u-v

The idea of using key values is to pick the minimum weight edge from the cut. The key values are used only for vertices that are not yet included in MST, the key value for these vertices indicates the minimum weight edges connecting them to the set of vertices included in MST.

## Pseudo Code

```PRIM(G, w, r):
for each u in G:
u.key = INF
u.p = NIL
r.key = 0
Q = G
while Q is not empty:
u = EXTRACT-MIN(Q)
if v in Q and w(u, v) < v.key:
v.p = u
v.key = w(u, v)
return G```

where ‘G’ is the graph, w is the weight function, r is the root node, ‘Q’ is a priority queue (heap) containing all the nodes in the graph, ‘Adj[u]’ is the list of neighbors of node ‘u’, and ‘EXTRACT-MIN(Q)‘ extracts the node with the minimum key value from the priority queue ‘Q’.

Let us understand with the following illustration:

Input graph:

Step 1: The set mstSet is initially empty and keys assigned to vertices are {0, INF, INF, INF, INF, INF, INF, INF} where INF indicates infinite. Now pick the vertex with the minimum key value. The vertex 0 is picked, include it in mstSet. So mstSet becomes {0}. After including it to mstSet, update key values of adjacent vertices. Adjacent vertices of 0 are 1 and 7. The key values of 1 and 7 are updated as 4 and 8. Following subgraph shows vertices and their key values, only the vertices with finite key values are shown. The vertices included in MST are shown in green color.

Step 2: Pick the vertex with minimum key value and which is not already included in the MST (not in mstSET). The vertex 1 is picked and added to mstSet. So mstSet now becomes {0, 1}. Update the key values of adjacent vertices of 1. The key value of vertex 2 becomes 8.

Step 3: Pick the vertex with minimum key value and which is not already included in the MST (not in mstSET). We can either pick vertex 7 or vertex 2, let vertex 7 is picked. So mstSet now becomes {0, 1, 7}. Update the key values of adjacent vertices of 7. The key value of vertex 6 and 8 becomes finite (1 and 7 respectively).

Step 4: Pick the vertex with minimum key value and not already included in MST (not in mstSET). Vertex 6 is picked. So mstSet now becomes {0, 1, 7, 6}. Update the key values of adjacent vertices of 6. The key value of vertex 5 and 8 are updated.

Step 5: Repeat the above steps until mstSet includes all vertices of given graph. Finally, we get the following graph.

Recommended Practice

## Coding implementation of Prim’s algorithm:

Use a boolean array mstSet[] to represent the set of vertices included in MST. If a value mstSet[v] is true, then vertex v is included in MST, otherwise not. Array key[] is used to store key values of all vertices. Another array parent[] to store indexes of parent nodes in MST. The parent array is the output array, which is used to show the constructed MST.

## C++

 `// A C++ program for Prim's Minimum` `// Spanning Tree (MST) algorithm. The program is` `// for adjacency matrix representation of the graph` `#include ` `using` `namespace` `std;`   `// Number of vertices in the graph` `#define V 5`   `// A utility function to find the vertex with` `// minimum key value, from the set of vertices` `// not yet included in MST` `int` `minKey(``int` `key[], ``bool` `mstSet[])` `{` `    ``// Initialize min value` `    ``int` `min = INT_MAX, min_index;`   `    ``for` `(``int` `v = 0; v < V; v++)` `        ``if` `(mstSet[v] == ``false` `&& key[v] < min)` `            ``min = key[v], min_index = v;`   `    ``return` `min_index;` `}`   `// A utility function to print the` `// constructed MST stored in parent[]` `void` `printMST(``int` `parent[], ``int` `graph[V][V])` `{` `    ``cout << ``"Edge \tWeight\n"``;` `    ``for` `(``int` `i = 1; i < V; i++)` `        ``cout << parent[i] << ``" - "` `<< i << ``" \t"` `             ``<< graph[i][parent[i]] << ``" \n"``;` `}`   `// Function to construct and print MST for` `// a graph represented using adjacency` `// matrix representation` `void` `primMST(``int` `graph[V][V])` `{` `    ``// Array to store constructed MST` `    ``int` `parent[V];`   `    ``// Key values used to pick minimum weight edge in cut` `    ``int` `key[V];`   `    ``// To represent set of vertices included in MST` `    ``bool` `mstSet[V];`   `    ``// Initialize all keys as INFINITE` `    ``for` `(``int` `i = 0; i < V; i++)` `        ``key[i] = INT_MAX, mstSet[i] = ``false``;`   `    ``// Always include first 1st vertex in MST.` `    ``// Make key 0 so that this vertex is picked as first` `    ``// vertex.` `    ``key[0] = 0;` `    ``parent[0] = -1; ``// First node is always root of MST`   `    ``// The MST will have V vertices` `    ``for` `(``int` `count = 0; count < V - 1; count++) {` `        ``// Pick the minimum key vertex from the` `        ``// set of vertices not yet included in MST` `        ``int` `u = minKey(key, mstSet);`   `        ``// Add the picked vertex to the MST Set` `        ``mstSet[u] = ``true``;`   `        ``// Update key value and parent index of` `        ``// the adjacent vertices of the picked vertex.` `        ``// Consider only those vertices which are not` `        ``// yet included in MST` `        ``for` `(``int` `v = 0; v < V; v++)`   `            ``// graph[u][v] is non zero only for adjacent` `            ``// vertices of m mstSet[v] is false for vertices` `            ``// not yet included in MST Update the key only` `            ``// if graph[u][v] is smaller than key[v]` `            ``if` `(graph[u][v] && mstSet[v] == ``false` `                ``&& graph[u][v] < key[v])` `                ``parent[v] = u, key[v] = graph[u][v];` `    ``}`   `    ``// print the constructed MST` `    ``printMST(parent, graph);` `}`   `// Driver's code` `int` `main()` `{` `    ``/* Let us create the following graph` `        ``2 3` `    ``(0)--(1)--(2)` `    ``| / \ |` `    ``6| 8/ \5 |7` `    ``| / \ |` `    ``(3)-------(4)` `            ``9     */` `    ``int` `graph[V][V] = { { 0, 2, 0, 6, 0 },` `                        ``{ 2, 0, 3, 8, 5 },` `                        ``{ 0, 3, 0, 0, 7 },` `                        ``{ 6, 8, 0, 0, 9 },` `                        ``{ 0, 5, 7, 9, 0 } };`   `    ``// Print the solution` `    ``primMST(graph);`   `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `// A C program for Prim's Minimum` `// Spanning Tree (MST) algorithm. The program is` `// for adjacency matrix representation of the graph` `#include ` `#include ` `#include `   `// Number of vertices in the graph` `#define V 5`   `// A utility function to find the vertex with` `// minimum key value, from the set of vertices` `// not yet included in MST` `int` `minKey(``int` `key[], ``bool` `mstSet[])` `{` `    ``// Initialize min value` `    ``int` `min = INT_MAX, min_index;`   `    ``for` `(``int` `v = 0; v < V; v++)` `        ``if` `(mstSet[v] == ``false` `&& key[v] < min)` `            ``min = key[v], min_index = v;`   `    ``return` `min_index;` `}`   `// A utility function to print the` `// constructed MST stored in parent[]` `int` `printMST(``int` `parent[], ``int` `graph[V][V])` `{` `    ``printf``(``"Edge \tWeight\n"``);` `    ``for` `(``int` `i = 1; i < V; i++)` `        ``printf``(``"%d - %d \t%d \n"``, parent[i], i,` `               ``graph[i][parent[i]]);` `}`   `// Function to construct and print MST for` `// a graph represented using adjacency` `// matrix representation` `void` `primMST(``int` `graph[V][V])` `{` `    ``// Array to store constructed MST` `    ``int` `parent[V];` `    ``// Key values used to pick minimum weight edge in cut` `    ``int` `key[V];` `    ``// To represent set of vertices included in MST` `    ``bool` `mstSet[V];`   `    ``// Initialize all keys as INFINITE` `    ``for` `(``int` `i = 0; i < V; i++)` `        ``key[i] = INT_MAX, mstSet[i] = ``false``;`   `    ``// Always include first 1st vertex in MST.` `    ``// Make key 0 so that this vertex is picked as first` `    ``// vertex.` `    ``key[0] = 0;` `    ``parent[0] = -1; ``// First node is always root of MST`   `    ``// The MST will have V vertices` `    ``for` `(``int` `count = 0; count < V - 1; count++) {` `        ``// Pick the minimum key vertex from the` `        ``// set of vertices not yet included in MST` `        ``int` `u = minKey(key, mstSet);`   `        ``// Add the picked vertex to the MST Set` `        ``mstSet[u] = ``true``;`   `        ``// Update key value and parent index of` `        ``// the adjacent vertices of the picked vertex.` `        ``// Consider only those vertices which are not` `        ``// yet included in MST` `        ``for` `(``int` `v = 0; v < V; v++)`   `            ``// graph[u][v] is non zero only for adjacent` `            ``// vertices of m mstSet[v] is false for vertices` `            ``// not yet included in MST Update the key only` `            ``// if graph[u][v] is smaller than key[v]` `            ``if` `(graph[u][v] && mstSet[v] == ``false` `                ``&& graph[u][v] < key[v])` `                ``parent[v] = u, key[v] = graph[u][v];` `    ``}`   `    ``// print the constructed MST` `    ``printMST(parent, graph);` `}`   `// driver's code` `int` `main()` `{` `    ``/* Let us create the following graph` `        ``2 3` `    ``(0)--(1)--(2)` `    ``| / \ |` `    ``6| 8/ \5 |7` `    ``| /     \ |` `    ``(3)-------(4)` `            ``9         */` `    ``int` `graph[V][V] = { { 0, 2, 0, 6, 0 },` `                        ``{ 2, 0, 3, 8, 5 },` `                        ``{ 0, 3, 0, 0, 7 },` `                        ``{ 6, 8, 0, 0, 9 },` `                        ``{ 0, 5, 7, 9, 0 } };`   `    ``// Print the solution` `    ``primMST(graph);`   `    ``return` `0;` `}`

## Java

 `// A Java program for Prim's Minimum Spanning Tree (MST)` `// algorithm. The program is for adjacency matrix` `// representation of the graph`   `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `MST {`   `    ``// Number of vertices in the graph` `    ``private` `static` `final` `int` `V = ``5``;`   `    ``// A utility function to find the vertex with minimum` `    ``// key value, from the set of vertices not yet included` `    ``// in MST` `    ``int` `minKey(``int` `key[], Boolean mstSet[])` `    ``{` `        ``// Initialize min value` `        ``int` `min = Integer.MAX_VALUE, min_index = -``1``;`   `        ``for` `(``int` `v = ``0``; v < V; v++)` `            ``if` `(mstSet[v] == ``false` `&& key[v] < min) {` `                ``min = key[v];` `                ``min_index = v;` `            ``}`   `        ``return` `min_index;` `    ``}`   `    ``// A utility function to print the constructed MST` `    ``// stored in parent[]` `    ``void` `printMST(``int` `parent[], ``int` `graph[][])` `    ``{` `        ``System.out.println(``"Edge \tWeight"``);` `        ``for` `(``int` `i = ``1``; i < V; i++)` `            ``System.out.println(parent[i] + ``" - "` `+ i + ``"\t"` `                               ``+ graph[i][parent[i]]);` `    ``}`   `    ``// Function to construct and print MST for a graph` `    ``// represented using adjacency matrix representation` `    ``void` `primMST(``int` `graph[][])` `    ``{` `        ``// Array to store constructed MST` `        ``int` `parent[] = ``new` `int``[V];`   `        ``// Key values used to pick minimum weight edge in` `        ``// cut` `        ``int` `key[] = ``new` `int``[V];`   `        ``// To represent set of vertices included in MST` `        ``Boolean mstSet[] = ``new` `Boolean[V];`   `        ``// Initialize all keys as INFINITE` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``key[i] = Integer.MAX_VALUE;` `            ``mstSet[i] = ``false``;` `        ``}`   `        ``// Always include first 1st vertex in MST.` `        ``key[``0``] = ``0``; ``// Make key 0 so that this vertex is` `        ``// picked as first vertex` `        ``parent[``0``] = -``1``; ``// First node is always root of MST`   `        ``// The MST will have V vertices` `        ``for` `(``int` `count = ``0``; count < V - ``1``; count++) {` `            ``// Pick thd minimum key vertex from the set of` `            ``// vertices not yet included in MST` `            ``int` `u = minKey(key, mstSet);`   `            ``// Add the picked vertex to the MST Set` `            ``mstSet[u] = ``true``;`   `            ``// Update key value and parent index of the` `            ``// adjacent vertices of the picked vertex.` `            ``// Consider only those vertices which are not` `            ``// yet included in MST` `            ``for` `(``int` `v = ``0``; v < V; v++)`   `                ``// graph[u][v] is non zero only for adjacent` `                ``// vertices of m mstSet[v] is false for` `                ``// vertices not yet included in MST Update` `                ``// the key only if graph[u][v] is smaller` `                ``// than key[v]` `                ``if` `(graph[u][v] != ``0` `&& mstSet[v] == ``false` `                    ``&& graph[u][v] < key[v]) {` `                    ``parent[v] = u;` `                    ``key[v] = graph[u][v];` `                ``}` `        ``}`   `        ``// print the constructed MST` `        ``printMST(parent, graph);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``/* Let us create the following graph` `        ``2 3` `        ``(0)--(1)--(2)` `        ``| / \ |` `        ``6| 8/ \5 |7` `        ``| /     \ |` `        ``(3)-------(4)` `            ``9         */` `        ``MST t = ``new` `MST();` `        ``int` `graph[][] = ``new` `int``[][] { { ``0``, ``2``, ``0``, ``6``, ``0` `},` `                                      ``{ ``2``, ``0``, ``3``, ``8``, ``5` `},` `                                      ``{ ``0``, ``3``, ``0``, ``0``, ``7` `},` `                                      ``{ ``6``, ``8``, ``0``, ``0``, ``9` `},` `                                      ``{ ``0``, ``5``, ``7``, ``9``, ``0` `} };`   `        ``// Print the solution` `        ``t.primMST(graph);` `    ``}` `}` `// This code is contributed by Aakash Hasija`

## Python3

 `# A Python3 program for Prim's Minimum Spanning Tree (MST) algorithm.` `# The program is for adjacency matrix representation of the graph`   `import` `sys  ``# Library for INT_MAX`     `class` `Graph():`   `    ``def` `__init__(``self``, vertices):` `        ``self``.V ``=` `vertices` `        ``self``.graph ``=` `[[``0` `for` `column ``in` `range``(vertices)]` `                      ``for` `row ``in` `range``(vertices)]`   `    ``# A utility function to print the constructed MST stored in parent[]` `    ``def` `printMST(``self``, parent):` `        ``print``(``"Edge \tWeight"``)` `        ``for` `i ``in` `range``(``1``, ``self``.V):` `            ``print``(parent[i], ``"-"``, i, ``"\t"``, ``self``.graph[i][parent[i]])`   `    ``# A utility function to find the vertex with` `    ``# minimum distance value, from the set of vertices` `    ``# not yet included in shortest path tree` `    ``def` `minKey(``self``, key, mstSet):`   `        ``# Initialize min value` `        ``min` `=` `sys.maxsize`   `        ``for` `v ``in` `range``(``self``.V):` `            ``if` `key[v] < ``min` `and` `mstSet[v] ``=``=` `False``:` `                ``min` `=` `key[v]` `                ``min_index ``=` `v`   `        ``return` `min_index`   `    ``# Function to construct and print MST for a graph` `    ``# represented using adjacency matrix representation` `    ``def` `primMST(``self``):`   `        ``# Key values used to pick minimum weight edge in cut` `        ``key ``=` `[sys.maxsize] ``*` `self``.V` `        ``parent ``=` `[``None``] ``*` `self``.V  ``# Array to store constructed MST` `        ``# Make key 0 so that this vertex is picked as first vertex` `        ``key[``0``] ``=` `0` `        ``mstSet ``=` `[``False``] ``*` `self``.V`   `        ``parent[``0``] ``=` `-``1`  `# First node is always the root of`   `        ``for` `cout ``in` `range``(``self``.V):`   `            ``# Pick the minimum distance vertex from` `            ``# the set of vertices not yet processed.` `            ``# u is always equal to src in first iteration` `            ``u ``=` `self``.minKey(key, mstSet)`   `            ``# Put the minimum distance vertex in` `            ``# the shortest path tree` `            ``mstSet[u] ``=` `True`   `            ``# Update dist value of the adjacent vertices` `            ``# of the picked vertex only if the current` `            ``# distance is greater than new distance and` `            ``# the vertex in not in the shortest path tree` `            ``for` `v ``in` `range``(``self``.V):`   `                ``# graph[u][v] is non zero only for adjacent vertices of m` `                ``# mstSet[v] is false for vertices not yet included in MST` `                ``# Update the key only if graph[u][v] is smaller than key[v]` `                ``if` `self``.graph[u][v] > ``0` `and` `mstSet[v] ``=``=` `False` `and` `key[v] > ``self``.graph[u][v]:` `                    ``key[v] ``=` `self``.graph[u][v]` `                    ``parent[v] ``=` `u`   `        ``self``.printMST(parent)`     `# Driver's code` `if` `__name__ ``=``=` `'__main__'``:` `    ``g ``=` `Graph(``5``)` `    ``g.graph ``=` `[[``0``, ``2``, ``0``, ``6``, ``0``],` `               ``[``2``, ``0``, ``3``, ``8``, ``5``],` `               ``[``0``, ``3``, ``0``, ``0``, ``7``],` `               ``[``6``, ``8``, ``0``, ``0``, ``9``],` `               ``[``0``, ``5``, ``7``, ``9``, ``0``]]`   `    ``g.primMST()`   `    ``# Contributed by Divyanshu Mehta`

## C#

 `// A C# program for Prim's Minimum` `// Spanning Tree (MST) algorithm.` `// The program is for adjacency` `// matrix representation of the graph`   `using` `System;` `class` `MST {`   `    ``// Number of vertices in the graph` `    ``static` `int` `V = 5;`   `    ``// A utility function to find` `    ``// the vertex with minimum key` `    ``// value, from the set of vertices` `    ``// not yet included in MST` `    ``static` `int` `minKey(``int``[] key, ``bool``[] mstSet)` `    ``{`   `        ``// Initialize min value` `        ``int` `min = ``int``.MaxValue, min_index = -1;`   `        ``for` `(``int` `v = 0; v < V; v++)` `            ``if` `(mstSet[v] == ``false` `&& key[v] < min) {` `                ``min = key[v];` `                ``min_index = v;` `            ``}`   `        ``return` `min_index;` `    ``}`   `    ``// A utility function to print` `    ``// the constructed MST stored in` `    ``// parent[]` `    ``static` `void` `printMST(``int``[] parent, ``int``[, ] graph)` `    ``{` `        ``Console.WriteLine(``"Edge \tWeight"``);` `        ``for` `(``int` `i = 1; i < V; i++)` `            ``Console.WriteLine(parent[i] + ``" - "` `+ i + ``"\t"` `                              ``+ graph[i, parent[i]]);` `    ``}`   `    ``// Function to construct and` `    ``// print MST for a graph represented` `    ``// using adjacency matrix representation` `    ``static` `void` `primMST(``int``[, ] graph)` `    ``{`   `        ``// Array to store constructed MST` `        ``int``[] parent = ``new` `int``[V];`   `        ``// Key values used to pick` `        ``// minimum weight edge in cut` `        ``int``[] key = ``new` `int``[V];`   `        ``// To represent set of vertices` `        ``// included in MST` `        ``bool``[] mstSet = ``new` `bool``[V];`   `        ``// Initialize all keys` `        ``// as INFINITE` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``key[i] = ``int``.MaxValue;` `            ``mstSet[i] = ``false``;` `        ``}`   `        ``// Always include first 1st vertex in MST.` `        ``// Make key 0 so that this vertex is` `        ``// picked as first vertex` `        ``// First node is always root of MST` `        ``key[0] = 0;` `        ``parent[0] = -1;`   `        ``// The MST will have V vertices` `        ``for` `(``int` `count = 0; count < V - 1; count++) {`   `            ``// Pick thd minimum key vertex` `            ``// from the set of vertices` `            ``// not yet included in MST` `            ``int` `u = minKey(key, mstSet);`   `            ``// Add the picked vertex` `            ``// to the MST Set` `            ``mstSet[u] = ``true``;`   `            ``// Update key value and parent` `            ``// index of the adjacent vertices` `            ``// of the picked vertex. Consider` `            ``// only those vertices which are` `            ``// not yet included in MST` `            ``for` `(``int` `v = 0; v < V; v++)`   `                ``// graph[u][v] is non zero only` `                ``// for adjacent vertices of m` `                ``// mstSet[v] is false for vertices` `                ``// not yet included in MST Update` `                ``// the key only if graph[u][v] is` `                ``// smaller than key[v]` `                ``if` `(graph[u, v] != 0 && mstSet[v] == ``false` `                    ``&& graph[u, v] < key[v]) {` `                    ``parent[v] = u;` `                    ``key[v] = graph[u, v];` `                ``}` `        ``}`   `        ``// print the constructed MST` `        ``printMST(parent, graph);` `    ``}`   `    ``// Driver's Code` `    ``public` `static` `void` `Main()` `    ``{`   `        ``/* Let us create the following graph` `        ``2 3` `        ``(0)--(1)--(2)` `        ``| / \ |` `        ``6| 8/ \5 |7` `        ``| / \ |` `        ``(3)-------(4)` `            ``9 */`   `        ``int``[, ] graph = ``new` `int``[, ] { { 0, 2, 0, 6, 0 },` `                                      ``{ 2, 0, 3, 8, 5 },` `                                      ``{ 0, 3, 0, 0, 7 },` `                                      ``{ 6, 8, 0, 0, 9 },` `                                      ``{ 0, 5, 7, 9, 0 } };`   `        ``// Print the solution` `        ``primMST(graph);` `    ``}` `}`   `// This code is contributed by anuj_67.`

## Javascript

 ``

Output

```Edge     Weight
0 - 1     2
1 - 2     3
0 - 3     6
1 - 4     5 ```

Time Complexity: O(V2), If the input graph is represented using an adjacency list, then the time complexity of Prim’s algorithm can be reduced to O(E log V) with the help of a binary heap.  In this implementation, we are always considering the spanning tree to start from the root of the graph
Auxiliary Space: O(V)

## # Approach no 2:

Here are the general steps to find the Minimum Spanning Tree (MST) using Prim’s algorithm:

1. Select an arbitrary starting vertex, and add it to the MST.

2. Create a priority queue of all remaining vertices, ordered by their distance from the vertices already in the MST.

3. Select the vertex with the smallest distance, and add it to the MST.

4.Update the distances of all vertices adjacent to the newly added vertex and add them to the priority queue.

5.Repeat steps 3 and 4 until all vertices have been added to the MST.

6.Here is an example of the pseudocode for Prim’s Algorithm.

#### Explanation :

• This pseudocode assumes that the graph G is represented as a set of vertices and edges, and that each vertex has a distance attribute that is initialized to infinity.
• It starts by selecting an arbitrary vertex and setting its distance to zero. Then it creates a priority queue of all the vertices in the graph.
• The algorithm then iterates through the priority queue and selects the vertex with the smallest distance, adding it to the MST.
• It then updates the distances of all the adjacent vertices to the newly added vertex and adding them to the priority queue.
• This process continues until the priority queue is empty, at which point the MST is complete and the function returns it.
• It’s worth to notice that this is just a high-level pseudocode and it might need to be adapted depending on the specific implementation and language you are using.

## C++

 `PrimMST(graph G)` `    ``for` `each vertex v in G:` `        ``v.distance = infinity` `    ``start = arbitrary vertex` `    ``start.distance = 0` `    ``priorityQueue = all vertices in G` `    ``while` `priorityQueue is not empty:` `        ``u = vertex with smallest distance in priorityQueue` `        ``remove` `u from priorityQueue` `        ``for` `each neighbor v of u:` `            ``if` `v is in priorityQueue and weight(u, v) < v.distance:` `                ``v.distance = weight(u, v)` `                ``v.parent = u` `    ``return` `MST`

My Personal Notes arrow_drop_up
Related Articles