Heapify Operation in Binary Heap

Table of content

Heapify method rearranges the elements of an array where the left and right sub-tree of ith element obeys the heap property.

Heapify Pseudocode

Max-Heapify(numbers[], i) 
leftchild := numbers[2i] 
rightchild := numbers [2i + 1] 
if leftchild ≤ numbers[].size and numbers[leftchild] > numbers[i] 
   largest := leftchild 
else 
   largest := i 
if rightchild ≤ numbers[].size and numbers[rightchild] > numbers[largest] 
   largest := rightchild 
if largest ≠ i 
   swap numbers[i] with numbers[largest] 
   Max-Heapify(numbers, largest)

When the provided array does not obey the heap property, Heap is built based on the following algorithm Build-Max-Heap (numbers[]).

Algorithm: Build-Max-Heap(numbers[]) 
numbers[].size := numbers[].length 
fori = ⌊ numbers[].length/2 ⌋ to 1 by -1 
   Max-Heapify (numbers[], i)

Example

Following are the implementations of this operation in various programming languages −

C C++ Java Python 
#include <stdio.h>
void swap(int arr[], int i, int j) {
   int temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
}
void maxHeapify(int arr[], int size, int i) {
   int leftChild = 2 * i + 1;
   int rightChild = 2 * i + 2;
   int largest = i;
   if (leftChild < size && arr[leftChild] > arr[largest])
      largest = leftChild;
   if (rightChild < size && arr[rightChild] > arr[largest])
      largest = rightChild;
   if (largest != i) {
      swap(arr, i, largest);
      maxHeapify(arr, size, largest); // Recursive call to continue heapifying
   }
}
void buildMaxHeap(int arr[], int size) {
   for (int i = size / 2 - 1; i >= 0; i--)
      maxHeapify(arr, size, i); // Start heapifying from the parent nodes in bottom-up order
}
int main() {
   int arr[] = { 3, 10, 4, 5, 1 }; // Initial Max-Heap (or any array)
   int size = sizeof(arr) / sizeof(arr[0]);
   buildMaxHeap(arr, size); // Build the Max-Heap from the given array
   printf("Max Heap: ");
   for (int i = 0; i < size; i++)
      printf("%d ", arr[i]); // Print the updated Max-Heap
   printf("\n");
   return 0;
}

Output

Max Heap: 10 5 4 3 1 

#include <iostream>
#include <vector>
using namespace std;
void swap(vector<int>& arr, int i, int j) {
   int temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
}
void maxHeapify(vector<int>& arr, int size, int i) {
   int leftChild = 2 * i + 1;
   int rightChild = 2 * i + 2;
   int largest = i;
   if (leftChild < size && arr[leftChild] > arr[largest])
      largest = leftChild;
   if (rightChild < size && arr[rightChild] > arr[largest])
      largest = rightChild;
   if (largest != i) {
      swap(arr, i, largest);
      maxHeapify(arr, size, largest); // Recursive call to continue heapifying
   }
}
void buildMaxHeap(vector<int>& arr, int size) {
   for (int i = size / 2 - 1; i >= 0; i--)
      maxHeapify(arr, size, i); // Start heapifying from the parent nodes in bottom-up order
}
int main() {
   vector<int> arr = { 3, 10, 4, 5, 1 }; // Initial Max-Heap (or any array)
   int size = arr.size();
   buildMaxHeap(arr, size); // Build the Max-Heap from the given array
   cout << "Max Heap: ";
   for (int i = 0; i < size; i++)
      cout << arr[i] << " "; // Print the updated Max-Heap
   cout << endl;
   return 0;
}

Output

Max Heap: 10 5 4 3 1

import java.util.Arrays;
public class MaxHeap {
   public static void swap(int arr[], int i, int j) {
      int temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
   }
   public static void maxHeapify(int arr[], int size, int i) {
      int leftChild = 2 * i + 1;
      int rightChild = 2 * i + 2;
      int largest = i;
      if (leftChild < size && arr[leftChild] > arr[largest])
          largest = leftChild;
      if (rightChild < size && arr[rightChild] > arr[largest])
          largest = rightChild;
      if (largest != i) {
          swap(arr, i, largest);
          maxHeapify(arr, size, largest); // Recursive call to continue heapifying
      }
   }
   public static void buildMaxHeap(int arr[]) {
      int size = arr.length;
      for (int i = size / 2 - 1; i >= 0; i--)
         maxHeapify(arr, size, i); // Start heapifying from the parent nodes in bottom-up order
   }
   public static void main(String args[]) {
      int arr[] = { 3, 10, 4, 5, 1 }; // Initial Max-Heap (or any array)
      buildMaxHeap(arr); // Build the Max-Heap from the given array
      System.out.print("Max Heap: ");
      for (int i = 0; i < arr.length; i++)
         System.out.print(arr[i] + " "); // Print the updated Max-Heap
      System.out.println();
   }
}

Output

Max Heap: 10 5 4 3 1 

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]
def max_heapify(arr, size, i):
    left_child = 2 * i + 1
    right_child = 2 * i + 2
    largest = i
    if left_child < size and arr[left_child] > arr[largest]:
        largest = left_child
    if right_child < size and arr[right_child] > arr[largest]:
        largest = right_child
    if largest != i:
        swap(arr, i, largest)
        max_heapify(arr, size, largest) # Recursive call to continue heapifying    
def build_max_heap(arr):
    size = len(arr)
    for i in range(size // 2 - 1, -1, -1):
        max_heapify(arr, size, i) # Start heapifying from the parent nodes in bottom-up order
arr = [3, 10, 4, 5, 1] # Initial Max-Heap (or any array)
build_max_heap(arr) # Build the Max-Heap from the given array
print("Max Heap:", arr) # Print the updated Max-Heap

Output

Max Heap: [10, 5, 4, 3, 1]
Advertisements