C++ Program to Implement Binary Heap

A binary heap is a complete binary tree that satisfies the heap property. The heap property states that for a max-heap, every parent node has a value greater than or equal to its children, and for a min-heap, every parent node has a value less than or equal to its children. Binary heaps are commonly used to implement priority queues because they provide an efficient way to access and modify the minimum or maximum element.

In this article, we will learn how to implement a binary heap in C++, including its basic operations along with their time and space complexity analysis.

Properties of a Binary Heap

A binary heap is a binary tree with the following properties:

• It's a complete tree: All levels are completely filled except possibly the last level and the last level has all keys as left as possible.
• It satisfies the heap property: In a max heap, for any given node C, if P is a parent node of C, then the key of P is greater than or equal to the key of C. In a min heap, the key of P is less than or equal to the key of C.

Implementation of Binary Heap in C++

A binary heap is typically implemented using an array. This is because the complete binary tree property allows us to use a simple array representation where the parent and child relationships are easily calculated using array indices.

The root element will be at Arr[0]. For any element at index i:

• Its left child is present at are at indices 2i+1.
• Its right child is present at 2i+2
• Its parent is present at (i-1)/2.

Representation of Binary Heap in C++

The following diagram demonstrates how a binary max heap is represented using an array in C++:

The following diagram demonstrates how a binary min heap is represented using an array in C++:

To represent a Binary Heap in C++, we will implement a class BinaryHeap and use a to store the elements of the heap. We'll implement a class to keep the binary heap generic so that it can store multiple data types.

template <typename T>
class BinaryHeap {
private:
 vector<T> heap;
 bool isMinHeap;
 int currentSize; 
 int maxCapacity;

here:

• heap: is the std:vector that will store the heap elements.
• isMinheap: is a flag variable to denote whether the binary heap is a min or max heap.
• currentsize: denotes the current size of the heap.
• maxCapacity: denotes the maximum capacity of the heap.

Basic operations of a Binary Heap in C++

Following are the basic operations that are required to work with a binary heap in C++:

Implementation of HeapifyDown Function (Min Heap)

1. Initialize the smallest node as the current node, i.
2. Calculate the left child index as 2i+12i + 12i+1.
3. Calculate the right child index as 2i+22i + 22i+2.
4. If the left child exists (i.e., it is within the array bounds) and is less than the current smallest node, update the smallest node to the left child.
5. If the right child exists (i.e., it is within the array bounds) and is less than the current smallest node, update the smallest node to the right child.
6. If the smallest node is not the current node, i, swap the current node with the smallest node using the std::swap function.
7. Recursively apply the heapify operation to the subtree rooted at the smallest node.

Implementation of Insert Node Function

1. Append the new key to the end of the array.
2. Initialize the index i as the index of the newly inserted key (last element of the array).
3. Call the heapifyUp

Implementation of Heapify Up Function

1. While the key at index i is less than its parent and i is not the root:
2. Swap the key with its parent.
3. Update i to the parent index.
4. Continue this process until the heap property is restored.

Implementation of Extract Min Function

1. Check if the heap is empty. If true, throw an underflow_error.
2. If the heap has only one element, remove and return that element.
3. Store the minimum value (root of the heap) in a temporary variable.
4. Replace the root of the heap with the last element in the array.
5. Remove the last element from the array.
6. Apply the heapify operation on the root to restore the heap property.
7. Return the stored minimum value.

Delete Key Implementation in C++

1. The deleteKey function is implemented with the function signature: void Heap::deleteKey(int i).
2. Check if the index i is valid (within the array bounds). If not, throw an out_of_range exception.
3. Replace the key at index i with the last element in the array.
4. Remove the last element from the array.
5. Apply the heapify operation on the subtree rooted at index i to restore the heap property.

Decrease Key Implementation in C++

1. The decreaseKey function is implemented with the function signature: void Heap::decreaseKey(int i, int newValue).
2. Check if the index i is valid and the new value is less than the current value. If not, throw an invalid_argument exception.
3. Update the value at index i to the new value.
4. While the key at index i is less than its parent and i is not the root:
   • Swap the key with its parent.
   • Update i to the parent index.
5. Continue this process until the heap property is restored.

Print Heap Implementation in C++

1. The printHeap function is implemented with the function signature: void Heap::printHeap() const.
2. Iterate through each element in the array.
3. Print each element followed by a space.
4. Print a newline at the end.

Program to Implement Binary Heap in C++

The following program demonstrates how we can implement a Binary Heap in C++:

Min Heap: 2 3 15 5 4 45 
Minimum element: 2
After extracting min: 3 4 15 5 45 
After deleting 4: 3 5 15 45 
After decreasing key at index 2 to 1: 1 5 3 45 

Applications of Binary Heap

Following are some of the common applications of Binary Heap:

• Priority Queues: Binary heaps are commonly used to implement priority queues.
• Heap Sort: Binary heap is used in the efficient sorting algorithm called heap sort.
• Graph Algorithms: Many graph algorithms like Dijkstra's shortest path and Prim's minimum spanning tree.
• Memory Management: In some memory allocation systems, a binary heap is used to quickly allocate and deallocate memory blocks of varying sizes.
• Data Compression: In Huffman coding, a binary heap is used to build the Huffman tree for data compression.
• Operating Systems: In operating systems, binary heaps can be used in task scheduling to manage processes based on their priorities.

Related Articles:

• Implement Heap in C++
• Binary Heap