Summary: In this tutorial, we will learn what Prim’s minimum spanning tree (lazy version) algorithm is and how can we implement it using languages such as Python, C++, and Java.

## What is a Minimum Spanning Tree?

A Minimum Spanning Tree (MST) of any graph is the minimum subsets of edges that can connect all the vertices without forming any cycle and with the minimum total cost.

For example, the total cost in the MST of the above graph is 11 and there is no cycle.

Note: A graph can have multiple spanning trees with same minimum total cost.

## Prim’s Minimum Spanning Tree Algorithm

Prim’s minimum spanning tree is a greedy algorithm that uses a priority queue to find the MST of the graph.

Priority Queue is a modified version of queue data structure that pops elements based on priority.

It pushes the edges (as it discovers) to the priority queue and fetches them in ascending order of costs to form the MST. At every vertex, the algorithm selects the least cost edge (green) from the list of edges (red) in the Priority Queue.

As depicted in the picture, it adds all the edges associated with the source vertex (vertex A) to the priority queue, then selects a low-cost edge using the same to move to the next vertex (vertex B).

The edge which it selects to move to the next vertex becomes a part of the MST.

It repeats the same process at vertex B and moves to vertex C.

At C it discovers two more edges (C—D and C—E) but chooses the edge connecting A and D (A—D) as it the lowest cost among the edges in the priority queue.

At vertex D, the algorithm discovers a final edge (D—E) with a cost of 1 and selects it to complete the MST.

Note: The left out edges are popped out to empty the priority queue.

When all edges are discovered and the priority queue is emptied, the algorithm stops.

### How to implement Prim’s algorithm in Programming?

Steps to implement Prim’s Minimum Spanning Tree algorithm:

1. Mark the source vertex as visited and add all the edges associated with it to the priority queue.
2. While priority queue is not empty and all the edges have not been discovered:
1. Pop the least cost edge from the priority queue.
2. Check if the target vertex of the popped edge is not have been visited before.
1. If so, then add the current edge to the MST.
2. Also, mark the target vertex as visited and add all the edges associated with it to the priority queue.
3. After the process is complete, check if all the edges were discovered.
4. If not, perhaps the graph is cut, and therefore its MST is not possible otherwise, output the MST.

Here is the program that implements the above steps to find the MST of a graph:

#### Python

``````from queue import PriorityQueue

class Vertex:
def __init__(self, name):
#vertex label
self.name = name
#edges connected to this vertex
self.edges = []
#visited flag
self.visited = False

#method to connect vertices through bi-directional edges
global totalEdges
totalEdges += 2

#string representation of the vertex class
def __repr__(self):
return self.name

class Edge:
def __init__(self, _from, _to, _cost):
#from vertex
self._from = _from
#to vertex
self._to = _to
#edge weight or cost
self._cost = _cost

#method to compare two edges (used by the priority queue)
def __lt__(self, other):
if isinstance(other, Edge):
return self._cost < other._cost
return False

#string representation of the edge class
def __repr__(self):
return f"{self._from}-----{self._to}"

class Prims:
def __init__(self):
self.pqueue = PriorityQueue()
self.mst = []
self.totalCost = 0

#function implementing Prim's algorithm
def findMST(self, s):
global totalEdges

#add all edges of the starting vertex
edgeCount = 0

'''
hunt for low costs edges using PriorityQueue
until all the edges are discovered
'''
while not self.pqueue.empty() and edgeCount != totalEdges:
#pop the low cost edge from PriorityQueue
minEdge = self.pqueue.get()

'''
'''
if minEdge._to.visited:
continue
else:
#increment count and add edge to MST
edgeCount += 1
self.totalCost += minEdge._cost
self.mst.append(minEdge)

'''
if not all edges are dicovered, then probalbly the
given graph is dicsconnected, hence MST is not possible.
'''
return edgeCount != totalEdges

#function add edges connected with a vertex to the priority queue
s.visited = True;
for edge in s.edges:
if not edge._to.visited:
self.pqueue.put(edge)

if __name__ == '__main__':
#total number of edges
totalEdges = 0

#vertices of the graph
vertices = [Vertex('A'), Vertex('B'), Vertex('C'), Vertex('D'), Vertex('E')]

#connecting vertices
vertices.connect(vertices, 3)
vertices.connect(vertices, 5)
vertices.connect(vertices, 2)
vertices.connect(vertices, 10)
vertices.connect(vertices, 7)
vertices.connect(vertices, 8)
vertices.connect(vertices, 1)

#driver code
prims = Prims()
if prims.findMST(vertices):
print(prims.mst)
print("Total Cost: ",prims.totalCost)
else:
print("MST not possible for given graph")
``````

#### C++

``````#include <iostream>
#include <list>
#include <queue>
using namespace std;

//vertex class prototype
class Vertex;

//total number of edges
int totalEdges = 0;

class Edge{
public:
//from vertex
Vertex* _from;
//to vertex
Vertex* _to;
//edge weight or cost
int _cost;

Edge(Vertex* _from, Vertex* _to, int _cost){
this->_from = _from;
this->_to = _to;
this->_cost = _cost;
}
};

class Vertex{
public:
//vertex label
char name;
//edges connected to this vertex
list<Edge*> edges;
//visited flag
bool visited;

Vertex(char name){
this->name = name;
this->visited = false;
}

//method to connect vertices through bi-directional edges
totalEdges += 2;
}
};

/*
*class compares two edges based on their cost
*Will be used by priority queue
*/
class Compare{
public:
bool operator()(Edge *e1, Edge *e2){
return e1->_cost < e2->_cost;
}
};

class Prims{
public:
priority_queue<Edge*, vector<Edge*>, Compare> pqueue;
list<Edge*> mst;
int totalCost= 0;

//function implementing Prim's algorithm
bool findMST(Vertex* s){
//add all edges of the starting vertex
int edgeCount = 0;

/*
hunt for low cost's edges using PriorityQueue
until all the edges are discovered
*/
while(!this->pqueue.empty() && edgeCount != totalEdges){
//pop the low cost edge from PriorityQueue
Edge* minEdge = this->pqueue.top();
this->pqueue.pop();

/*
*/
if(minEdge->_to->visited)
continue;
else{
//increment count and add edge to MST
edgeCount += 1;
this->totalCost += minEdge->_cost;
this->mst.push_back(minEdge);
}
}

/*
if not all edges are dicovered, then probalbly the
given graph is dicsconnected, hence MST is not possible.
*/
return edgeCount != totalEdges;
}

//function add edges connected with a vertex to the priority queue
s->visited = true;
for(Edge* edge: s->edges){
if(!edge->_to->visited)
this->pqueue.push(edge);
}
}
};

int main() {
//total number of edges
totalEdges = 0;

//vertices of the graph
Vertex* vertices[] = {new Vertex('A'), new Vertex('B'), new  Vertex('C'), new Vertex('D'), new Vertex('E')};

//connecting vertices
vertices->connect(vertices, 3);
vertices->connect(vertices, 5);
vertices->connect(vertices, 2);
vertices->connect(vertices, 10);
vertices->connect(vertices, 7);
vertices->connect(vertices, 8);
vertices->connect(vertices, 1);

//driver code
Prims prims;
if(prims.findMST(vertices)){
for(Edge* edge: prims.mst){
cout << edge->_from->name << "----" << edge->_to->name << "\n";
}
cout << "Total Cost: " << prims.totalCost;
}
else
cout << "MST not possible for given graph";
}``````

#### Java

``````import java.util.*;

class Edge implements Comparable<Edge>{
//from vertex
Vertex _from;
//to vertex
Vertex _to;
//edge weight or cost
int _cost;
//total number of edges in the graph
static int totalEdges = 0;

//constructor
Edge(Vertex _from, Vertex _to, int _cost){
this._from = _from;
this._to = _to;
this._cost = _cost;
}

/*
*function compares two edges based on their cost
*Will be used by the priority queue
*/
@Override
public int compareTo(Edge e) {
return (int) (this._cost - e._cost);
}

@Override
public String toString(){
return this._from.name+"----"+this._to.name;
}
}

class Vertex{
//vertex label
char name;
//edges connected to this vertex
List<Edge> edges;
//visited flag
boolean visited;

Vertex(char name){
this.name = name;
this.visited = false;
this.edges = new ArrayList<>();
}

//method to connect vertices through bi-directional edges
Edge.totalEdges += 2;
}
}

class Prims{
PriorityQueue<Edge> pqueue = new PriorityQueue<>();
List<Edge> mst = new ArrayList<>();
int totalCost= 0;

//function implementing Prim's algorithm
boolean findMST(Vertex s){
//add all edges of the starting vertex
int edgeCount = 0;

/*
hunt for low cost's edges using PriorityQueue
until all the edges are discovered
*/
while(!this.pqueue.isEmpty() && edgeCount != Edge.totalEdges){
//pop the low cost edge from PriorityQueue
Edge minEdge = this.pqueue.peek();
this.pqueue.poll();

/*
*/
if(minEdge._to.visited)
continue;
else{
//increment count and add edge to MST
edgeCount += 1;
this.totalCost += minEdge._cost;
}
}

/*
if not all edges are dicovered, then probalbly the
given graph is dicsconnected, hence MST not possible.
*/
return edgeCount != Edge.totalEdges;
}

//function add edges connected with a vertex to the priority queue
s.visited = true;
for(Edge edge: s.edges){
if(!edge._to.visited)
}
}
}

class Main {
public static void main(String[] args) {
//vertices of the graph
Vertex vertices[] = {new Vertex('A'), new Vertex('B'), new  Vertex('C'), new Vertex('D'), new Vertex('E')};

//connecting vertices
vertices.connect(vertices, 3);
vertices.connect(vertices, 5);
vertices.connect(vertices, 2);
vertices.connect(vertices, 10);
vertices.connect(vertices, 7);
vertices.connect(vertices, 8);
vertices.connect(vertices, 1);

//driver code
Prims prims= new Prims();
if(prims.findMST(vertices)){
System.out.println(prims.mst);
System.out.println("Total Cost: "+ prims.totalCost);
}
else{
System.out.println("MST not possible for given graph");
}
}
}``````

Output:

[A—-B, B—-C, A—-D, D—-E]
Total Cost: 11

In the above programs, we specifically define the priority (priorities low-cost edges) of the edges using the `__lt__` method in Python, `Compare` class in C++ and `Comparable` interface in Java.

## Overview of the Prim’s Algorithm

Prim’s Minimum Spanning Tree algorithm works well on the dense graph but fails when the graph is disconnected.

The algorithm has a runtime of O(E*log(E)) (lazy) which can be optimized (eager) to make it more time efficient.