** Input:** Given a graph with N nodes and M weighted edges, we want to obtain the **Minimum Spanning Tree** (**MST**) of the graph.

*Note*:**MST** is a tree that is formed in a graph which makes all the graph nodes

connected with the minimum total edges weights, also cycles isn’t allowed in the tree.

**Output:** Using Prim’s algorithm , we obtain a tree (collection of nodes and edges) that

satisfy the above conditions (The green edges in the figure forms the MST).

**Algorithm Steps (Taken from Wikipedia):**

- Initialize a tree with a single vertex, chosen arbitrarily from the graph.
- Grow the tree by one edge of the edges that connect the tree to vertices not yet in the tree, find the minimum-weight edge, and transfer it to the tree.
- Repeat step 2 (until all vertices are in the tree).

To be able to put all the graph nodes to the tree, we need to iterate all over the graph nodes. So, the operation costs **O(N)**.

In each iteration, we obtain the minimum edge weight to grow the tree. Regularly, getting the minimum value costs **O(X) **where **X** is the size of the data. Here, we have **M **edges. To find the minimum edge per iteration, we need to form **O(M)** iteration at most where **M **is the number of graph edges.

Combining the both, we obtain the final running time which is **O(NM).**

**Time Improvement Proof Using Heaps:**

Heap is a data structure that is popular among programming languages. Nearly all programming languages implement it in their *Collections *or *Abstract Data Types.*

The heap is a binary tree (each node has only 2 children), if it is a max heap then the tree sorts the values so that the direct root and parent nodes are always higher than the children, if it is a min heap then the tree sorts the values so that the direct root and parent nodes are always lower than the children.

The tree supports many operations with low running time compared to the naive implementations.

**The Improved Algorithm Steps will be:**

- Create a Min Heap with size of N
*(costs O(N))* - Initialize the heap with a node with cost 0 as it is the root node
- While the heap isn’t empty, do the following

– Extract the minimum node value*u*from the heap*(costs O(1))*

– Delete the extracted node as it is visited*(costs O(log(N)))*

– Get the adjacent nodes*v*from the extracted node– For every adjacent node*(costs O(M) at most where M >= (N – 1) in the worst case)*

*v*, check if it is in the heap and not included in the MST

– If it is in the heap but it can be relaxed (update the u-v weight with lower weight) and insert the new value of vAdd u to the MST*(costs O(log(N)))*

–

So, the final running time will be **O(M log(N))**, where **M **is the number of edges and **N **is the number of nodes.

**References**

https://en.wikipedia.org/wiki/Binary_heap

https://en.wikipedia.org/wiki/Heap_(data_structure)

https://en.wikipedia.org/wiki/Prim%27s_algorithm