Convert Min Heap to Max Heap
Last Updated :
17 Jan, 2023
Given an array representation of min Heap, convert it to max Heap.
Examples:
Input: arr[] = {3, 5, 9, 6, 8, 20, 10, 12, 18, 9}
3
/ \
5 9
/ \ / \
6 8 20 10
/ \ /
12 18 9
Output: arr[] = {20, 18, 10, 12, 9, 9, 3, 5, 6, 8}
20
/ \
18 10
/ \ / \
12 9 9 3
/ \ /
5 6 8
Input: arr[] = {3, 4, 8, 11, 13}
Output: arr[] = {13, 11, 8, 4, 3}
Approach: To solve the problem follow the below idea:
The idea is, simply build Max Heap without caring about the input. Start from the bottom-most and rightmost internal node of Min-Heap and heapify all internal nodes in the bottom-up way to build the Max heap.
Follow the given steps to solve the problem:
- Call the Heapify function from the rightmost internal node of Min-Heap
- Heapify all internal nodes in the bottom-up way to build max heap
- Print the Max-Heap
Algorithm: Here's an algorithm for converting a min heap to a max heap:
- Start at the last non-leaf node of the heap (i.e., the parent of the last leaf node). For a binary heap, this node is located at the index floor((n - 1)/2), where n is the number of nodes in the heap.
- For each non-leaf node, perform a "heapify" operation to fix the heap property. In a min heap, this operation involves checking whether the value of the node is greater than that of its children, and if so, swapping the node with the smaller of its children. In a max heap, the operation involves checking whether the value of the node is less than that of its children, and if so, swapping the node with the larger of its children.
- Repeat step 2 for each of the non-leaf nodes, working your way up the heap. When you reach the root of the heap, the entire heap should now be a max heap.
Below is the implementation of the above approach:
C
// C program to convert min Heap to max Heap
#include <stdio.h>
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// to heapify a subtree with root at given index
void MaxHeapify(int arr[], int i, int N)
{
int l = 2 * i + 1;
int r = 2 * i + 2;
int largest = i;
if (l < N && arr[l] > arr[i])
largest = l;
if (r < N && arr[r] > arr[largest])
largest = r;
if (largest != i) {
swap(&arr[i], &arr[largest]);
MaxHeapify(arr, largest, N);
}
}
// This function basically builds max heap
void convertMaxHeap(int arr[], int N)
{
// Start from bottommost and rightmost
// internal node and heapify all internal
// nodes in bottom up way
for (int i = (N - 2) / 2; i >= 0; --i)
MaxHeapify(arr, i, N);
}
// A utility function to print a given array
// of given size
void printArray(int* arr, int size)
{
for (int i = 0; i < size; ++i)
printf("%d ", arr[i]);
}
// Driver's code
int main()
{
// array representing Min Heap
int arr[] = { 3, 5, 9, 6, 8, 20, 10, 12, 18, 9 };
int N = sizeof(arr) / sizeof(arr[0]);
printf("Min Heap array : ");
printArray(arr, N);
// Function call
convertMaxHeap(arr, N);
printf("\nMax Heap array : ");
printArray(arr, N);
return 0;
}
C++
// A C++ program to convert min Heap to max Heap
#include <bits/stdc++.h>
using namespace std;
// to heapify a subtree with root at given index
void MaxHeapify(int arr[], int i, int N)
{
int l = 2 * i + 1;
int r = 2 * i + 2;
int largest = i;
if (l < N && arr[l] > arr[i])
largest = l;
if (r < N && arr[r] > arr[largest])
largest = r;
if (largest != i) {
swap(arr[i], arr[largest]);
MaxHeapify(arr, largest, N);
}
}
// This function basically builds max heap
void convertMaxHeap(int arr[], int N)
{
// Start from bottommost and rightmost
// internal node and heapify all internal
// nodes in bottom up way
for (int i = (N - 2) / 2; i >= 0; --i)
MaxHeapify(arr, i, N);
}
// A utility function to print a given array
// of given size
void printArray(int* arr, int size)
{
for (int i = 0; i < size; ++i)
cout << arr[i] << " ";
}
// Driver's code
int main()
{
// array representing Min Heap
int arr[] = { 3, 5, 9, 6, 8, 20, 10, 12, 18, 9 };
int N = sizeof(arr) / sizeof(arr[0]);
printf("Min Heap array : ");
printArray(arr, N);
// Function call
convertMaxHeap(arr, N);
printf("\nMax Heap array : ");
printArray(arr, N);
return 0;
}
Java
// Java program to convert min Heap to max Heap
class GFG {
// To heapify a subtree with root at given index
static void MaxHeapify(int arr[], int i, int N)
{
int l = 2 * i + 1;
int r = 2 * i + 2;
int largest = i;
if (l < N && arr[l] > arr[i])
largest = l;
if (r < N && arr[r] > arr[largest])
largest = r;
if (largest != i) {
// swap arr[i] and arr[largest]
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
MaxHeapify(arr, largest, N);
}
}
// This function basically builds max heap
static void convertMaxHeap(int arr[], int N)
{
// Start from bottommost and rightmost
// internal node and heapify all internal
// nodes in bottom up way
for (int i = (N - 2) / 2; i >= 0; --i)
MaxHeapify(arr, i, N);
}
// A utility function to print a given array
// of given size
static void printArray(int arr[], int size)
{
for (int i = 0; i < size; ++i)
System.out.print(arr[i] + " ");
}
// driver's code
public static void main(String[] args)
{
// array representing Min Heap
int arr[] = { 3, 5, 9, 6, 8, 20, 10, 12, 18, 9 };
int N = arr.length;
System.out.print("Min Heap array : ");
printArray(arr, N);
// Function call
convertMaxHeap(arr, N);
System.out.print("\nMax Heap array : ");
printArray(arr, N);
}
}
// Contributed by Pramod Kumar
Python3
# A Python3 program to convert min Heap
# to max Heap
# to heapify a subtree with root
# at given index
def MaxHeapify(arr, i, N):
l = 2 * i + 1
r = 2 * i + 2
largest = i
if l < N and arr[l] > arr[i]:
largest = l
if r < N and arr[r] > arr[largest]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
MaxHeapify(arr, largest, N)
# This function basically builds max heap
def convertMaxHeap(arr, N):
# Start from bottommost and rightmost
# internal node and heapify all
# internal nodes in bottom up way
for i in range(int((N - 2) / 2), -1, -1):
MaxHeapify(arr, i, N)
# A utility function to print a
# given array of given size
def printArray(arr, size):
for i in range(size):
print(arr[i], end=" ")
print()
# Driver Code
if __name__ == '__main__':
# array representing Min Heap
arr = [3, 5, 9, 6, 8, 20, 10, 12, 18, 9]
N = len(arr)
print("Min Heap array : ")
printArray(arr, N)
# Function call
convertMaxHeap(arr, N)
print("Max Heap array : ")
printArray(arr, N)
# This code is contributed by PranchalK
C#
// C# program to convert
// min Heap to max Heap
using System;
class GFG {
// To heapify a subtree with
// root at given index
static void MaxHeapify(int[] arr, int i, int n)
{
int l = 2 * i + 1;
int r = 2 * i + 2;
int largest = i;
if (l < n && arr[l] > arr[i])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i) {
// swap arr[i] and arr[largest]
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
MaxHeapify(arr, largest, n);
}
}
// This function basically
// builds max heap
static void convertMaxHeap(int[] arr, int n)
{
// Start from bottommost and
// rightmost internal node and
// heapify all internal nodes
// in bottom up way
for (int i = (n - 2) / 2; i >= 0; --i)
MaxHeapify(arr, i, n);
}
// A utility function to print
// a given array of given size
static void printArray(int[] arr, int size)
{
for (int i = 0; i < size; ++i)
Console.Write(arr[i] + " ");
}
// Driver's Code
public static void Main()
{
// array representing Min Heap
int[] arr = { 3, 5, 9, 6, 8, 20, 10, 12, 18, 9 };
int n = arr.Length;
Console.Write("Min Heap array : ");
printArray(arr, n);
// Function call
convertMaxHeap(arr, n);
Console.Write("\nMax Heap array : ");
printArray(arr, n);
}
}
// This code is contributed by nitin mittal.
PHP
<?php
// A PHP program to convert min Heap to max Heap
// utility swap function
function swap(&$a,&$b)
{
$tmp=$a;
$a=$b;
$b=$tmp;
}
// to heapify a subtree with root at given index
function MaxHeapify(&$arr, $i, $n)
{
$l = 2*$i + 1;
$r = 2*$i + 2;
$largest = $i;
if ($l < $n && $arr[$l] > $arr[$i])
$largest = $l;
if ($r < $n && $arr[$r] > $arr[$largest])
$largest = $r;
if ($largest != $i)
{
swap($arr[$i], $arr[$largest]);
MaxHeapify($arr, $largest, $n);
}
}
// This function basically builds max heap
function convertMaxHeap(&$arr, $n)
{
// Start from bottommost and rightmost
// internal node and heapify all internal
// nodes in bottom up way
for ($i = (int)(($n-2)/2); $i >= 0; --$i)
MaxHeapify($arr, $i, $n);
}
// A utility function to print a given array
// of given size
function printArray($arr, $size)
{
for ($i = 0; $i <$size; ++$i)
print($arr[$i]." ");
}
// Driver code
// array representing Min Heap
$arr = array(3, 5, 9, 6, 8, 20, 10, 12, 18, 9);
$n = count($arr);
print("Min Heap array : ");
printArray($arr, $n);
convertMaxHeap($arr, $n);
print("\nMax Heap array : ");
printArray($arr, $n);
// This code is contributed by mits
?>
JavaScript
<script>
// javascript program to convert min Heap to max Heap
// To heapify a subtree with root at given index
function MaxHeapify(arr , i , n)
{
var l = 2*i + 1;
var r = 2*i + 2;
var largest = i;
if (l < n && arr[l] > arr[i])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i)
{
// swap arr[i] and arr[largest]
var temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
MaxHeapify(arr, largest, n);
}
}
// This function basically builds max heap
function convertMaxHeap(arr , n)
{
// Start from bottommost and rightmost
// internal node and heapify all internal
// nodes in bottom up way
for (i = (n-2)/2; i >= 0; --i)
MaxHeapify(arr, i, n);
}
// A utility function to print a given array
// of given size
function printArray(arr , size)
{
for (i = 0; i < size; ++i)
document.write(arr[i]+" ");
}
// driver program
// array representing Min Heap
var arr = [3, 5, 9, 6, 8, 20, 10, 12, 18, 9];
var n = arr.length;
document.write("Min Heap array : ");
printArray(arr, n);
convertMaxHeap(arr, n);
document.write("<br>Max Heap array : ");
printArray(arr, n);
// This code is contributed by 29AjayKumar
</script>
OutputMin Heap array : 3 5 9 6 8 20 10 12 18 9
Max Heap array : 20 18 10 12 9 9 3 5 6 8
Time Complexity: O(N), for details, please refer: Time Complexity of building a heap
Auxiliary Space: O(N)
Similar Reads
Heap Data Structure A Heap is a complete binary tree data structure that satisfies the heap property: for every node, the value of its children is greater than or equal to its own value. Heaps are usually used to implement priority queues, where the smallest (or largest) element is always at the root of the tree.Basics
2 min read
Introduction to Heap - Data Structure and Algorithm Tutorials A Heap is a special tree-based data structure with the following properties:It is a complete binary tree (all levels are fully filled except possibly the last, which is filled from left to right).It satisfies either the max-heap property (every parent node is greater than or equal to its children) o
15+ min read
Binary Heap A Binary Heap is a complete binary tree that stores data efficiently, allowing quick access to the maximum or minimum element, depending on the type of heap. It can either be a Min Heap or a Max Heap. In a Min Heap, the key at the root must be the smallest among all the keys in the heap, and this pr
13 min read
Advantages and Disadvantages of Heap Advantages of Heap Data StructureTime Efficient: Heaps have an average time complexity of O(log n) for inserting and deleting elements, making them efficient for large datasets. We can convert any array to a heap in O(n) time. The most important thing is, we can get the min or max in O(1) timeSpace
2 min read
Time Complexity of building a heap Consider the following algorithm for building a Heap of an input array A. A quick look over the above implementation suggests that the running time is O(n * lg(n)) since each call to Heapify costs O(lg(n)) and Build-Heap makes O(n) such calls. This upper bound, though correct, is not asymptotically
2 min read
Applications of Heap Data Structure Heap Data Structure is generally taught with Heapsort. Heapsort algorithm has limited uses because Quicksort is better in practice. Nevertheless, the Heap data structure itself is enormously used. Priority Queues: Heaps are commonly used to implement priority queues, where elements with higher prior
2 min read
Comparison between Heap and Tree What is Heap? A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Types of Heap Data Structure: Generally, Heaps can be of two types: Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of its children. The sa
3 min read
When building a Heap, is the structure of Heap unique? What is Heap? A heap is a tree based data structure where the tree is a complete binary tree that maintains the property that either the children of a node are less than itself (max heap) or the children are greater than the node (min heap). Properties of Heap: Structural Property: This property sta
4 min read
Some other type of Heap
Easy problems on Heap
Check if a given Binary Tree is a HeapGiven a binary tree, check if it has heap property or not, Binary tree needs to fulfil the following two conditions for being a heap: It should be a complete tree (i.e. Every level of the tree, except possibly the last, is completely filled, and all nodes are as far left as possible.).Every nodeâs v
15+ min read
How to check if a given array represents a Binary Heap?Given an array, how to check if the given array represents a Binary Max-Heap.Examples: Input: arr[] = {90, 15, 10, 7, 12, 2} Output: True The given array represents below tree 90 / \ 15 10 / \ / 7 12 2 The tree follows max-heap property as every node is greater than all of its descendants. Input: ar
11 min read
Iterative HeapSortHeapSort is a comparison-based sorting technique where we first build Max Heap and then swap the root element with the last element (size times) and maintains the heap property each time to finally make it sorted. Examples: Input : 10 20 15 17 9 21 Output : 9 10 15 17 20 21 Input: 12 11 13 5 6 7 15
11 min read
Find k largest elements in an arrayGiven an array arr[] and an integer k, the task is to find k largest elements in the given array. Elements in the output array should be in decreasing order.Examples:Input: [1, 23, 12, 9, 30, 2, 50], k = 3Output: [50, 30, 23]Input: [11, 5, 12, 9, 44, 17, 2], k = 2Output: [44, 17]Table of Content[Nai
15+ min read
Kâth Smallest Element in Unsorted ArrayGiven an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K'th smallest element in the given array. Examples:Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3 Output: 7Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4 Output: 10 Table of Content[Naive Ap
15 min read
Height of a complete binary tree (or Heap) with N nodesConsider a Binary Heap of size N. We need to find the height of it. Examples: Input : N = 6 Output : 2 () / \ () () / \ / () () () Input : N = 9 Output : 3 () / \ () () / \ / \ () () () () / \ () ()Recommended PracticeHeight of HeapTry It! Let the size of the heap be N and the height be h. If we tak
3 min read
Heap Sort for decreasing order using min heapGiven an array of elements, sort the array in decreasing order using min heap. Examples: Input : arr[] = {5, 3, 10, 1}Output : arr[] = {10, 5, 3, 1}Input : arr[] = {1, 50, 100, 25}Output : arr[] = {100, 50, 25, 1}Prerequisite: Heap sort using min heap.Using Min Heap Implementation - O(n Log n) Time
11 min read