What Is the Running Time of Prim’s Algorithm if We Are Using the Ordinary Heap Data Structure?


Larry Thompson

What Is the Running Time of Prim’s Algorithm if We Are Using the Ordinary Heap Data Structure?

When it comes to finding the minimum spanning tree of a weighted undirected graph, Prim’s algorithm is a popular choice. It guarantees that the resulting tree is both minimal and connected.

However, one important aspect to consider when implementing Prim’s algorithm is the data structure used for maintaining the priority queue of edges. In this article, we will discuss the running time of Prim’s algorithm if we are using the ordinary heap data structure.

Understanding Prim’s Algorithm

Before diving into the running time analysis, let’s briefly recap how Prim’s algorithm works. The algorithm starts with an arbitrary vertex and repeatedly adds an edge with minimum weight that connects a visited vertex to an unvisited vertex.

This process continues until all vertices are visited, resulting in a minimum spanning tree.

The Ordinary Heap Data Structure

To efficiently select the edge with minimum weight at each step, Prim’s algorithm relies on a priority queue data structure. In this case, we will focus on using an ordinary heap as our priority queue implementation.

A heap is a binary tree-based data structure that satisfies two key properties:

  • Heap Order Property: For any node ‘x’, its parent node ‘y’ has a lesser value than ‘x’ (in case of min-heap) or greater value than ‘x’ (in case of max-heap).
  • Complete Binary Tree Property: All levels of the tree are fully filled except possibly for the last level, which is filled from left to right.

The ordinary heap can be implemented as an array where each node’s index can be calculated based on its position in the tree. This allows for efficient insertion, deletion, and retrieval of the minimum value.

Running Time Analysis

When using the ordinary heap data structure for Prim’s algorithm, the running time can be analyzed as follows:

  1. Initialization: The algorithm initializes the heap with all vertices, resulting in a time complexity of O(V), where V is the number of vertices in the graph.
  2. Main Loop: The main loop runs V times, each time extracting an edge with minimum weight from the heap. Extracting an edge takes O(log V) time complexity due to heap operations.
  3. Decrease Key Operation: After extracting an edge, we need to update the keys (weights) of neighboring vertices. This operation takes O(E log V) time complexity in total, where E is the number of edges in the graph.

Therefore, when using the ordinary heap data structure, Prim’s algorithm has a running time complexity of O(V log V + E log V). In terms of its worst-case scenario, when E is proportional to V^2, this can be simplified to O(V^2 log V).


In conclusion, when implementing Prim’s algorithm using the ordinary heap data structure for maintaining a priority queue of edges, the running time complexity is O(V log V + E log V) or O(V^2 log V) in its worst-case scenario.

Understanding and analyzing the running time of algorithms is crucial for determining their efficiency and scalability. By considering different data structures and their associated complexities, we can make informed choices when implementing algorithms like Prim’s algorithm.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy