Heap (Priority Queue)

A Heap, particularly in the context of a Priority Queue, is an abstract data structure that plays a crucial role in computer science and programming. To understand it from first principles, let's start with its basic characteristics and then delve into how it operates and is implemented.

1. What is a Heap?

At its core, a heap is a specialized tree-based data structure. It satisfies two primary properties:

  • Heap Property: This can be of two types:

    • Min-Heap: The key (value) of each node is greater than or equal to the key of its parent, with the minimum-key at the root.
    • Max-Heap: The key of each node is less than or equal to the key of its parent, with the maximum-key at the root.
  • Shape Property: A heap is a complete binary tree. This means that every level, except possibly the last, is fully filled, and all nodes are as far left as possible.

2. Relationship with Priority Queue

A Priority Queue is an abstract data type that operates much like a regular queue or stack data structure, but with an added feature: each element has a "priority" associated with it. In a priority queue, an element with high priority is served before an element with low priority. Heaps are an excellent way to implement priority queues because they allow for efficient access to the highest (or lowest) priority element.

3. Operations in a Heap

The primary operations that a heap must support, particularly for its role in implementing a priority queue, are:

  • Insertion (add): Adds a new element to the heap. The process is as follows:

    1. The new element is initially appended to the last position of the heap (maintaining the shape property).
    2. The heap property is restored by comparing the added element with its parent and moving it up the tree (heapify up or bubble up) until the heap property is restored.
  • Removal (poll): Removes and returns the root element (the max in a max-heap or min in a min-heap) of the heap. The process is:

    1. The root element is removed, and the last element in the heap is temporarily moved to the root position (to maintain the shape property).
    2. The heap property is then restored by comparing the new root with its children and swapping it with one of them (heapify down or bubble down) until the heap property is restored.
  • Peek: Returns the root element without removing it from the heap.

4. Efficiency

Heaps are efficient for both access and mutation:

  • Access: The top priority element can be accessed in O(1) time.
  • Insertion and Removal: Both operations can be performed in O(log n) time, where n is the number of elements in the heap. This is because the height of a complete binary tree (which a heap is) is log n, and the operations require traversing at most from the root to a leaf or vice versa.

5. Implementation

Heaps are usually implemented using arrays (or lists in some languages), where the children of the element at index i are found at indexes 2i + 1 and 2i + 2, and the parent of an element at index i is found at index (i-1)/2.


Heaps, particularly when used as priority queues, offer a highly efficient means of managing data in a way that allows quick access to the highest or lowest priority elements. They are a fundamental data structure in computer science, used in various applications like sorting algorithms (Heap Sort), graph algorithms (like Dijkstra's algorithm), and many others. Their combination of efficiency and simplicity makes them an important tool in the programmer's toolkit.