# What Is Heapify in Data Structure?

//

Heather Bennett

In the field of data structures, heapify is an important concept that plays a crucial role in optimizing certain operations. Heapify refers to the process of transforming a binary tree into a heap, specifically a binary heap.

## What is a Binary Heap?

A binary heap is a complete binary tree that satisfies the heap property. The heap property states that for every node in the tree, its value must be greater than or equal to (in case of a max heap) or less than or equal to (in case of a min heap) the values of its children.

### Types of Binary Heaps

There are two types of binary heaps:

• Max Heap: In a max heap, the parent node always has a greater value than its children.
• Min Heap: In a min heap, the parent node always has a smaller value than its children.

## The Importance of Heapify

The process of transforming an arbitrary binary tree into a binary heap is known as heapify. This transformation is important for maintaining the structure and properties required for efficient operations on heaps.

### Operations on Heap

Heapify operation is crucial for various operations performed on heaps:

• Insertion: When inserting an element into a heap, it needs to be added at the appropriate position while maintaining the heap property. Heapify ensures that the newly inserted element is placed correctly and maintains the overall structure.
• Deletion/Extraction: When removing an element from a heap (usually the root element), it needs to be replaced with another element while still maintaining the structure and heap property.

Heapify helps in choosing the appropriate replacement element and rearranging the remaining elements accordingly.

• Building a Heap: Heapify is used to build a heap from an array of elements. It starts with the last non-leaf node and applies heapify operation to all nodes until the root, resulting in a valid heap.

## Heapify Algorithm

The heapify algorithm can be implemented in two ways:

### 1. Recursive Approach:

The recursive approach involves applying heapify operation on each subtree recursively, starting from the root.

``````
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])
largest = left;

if (right < n && arr[right] > arr[largest])
largest = right;

if (largest != i) {
swap(arr[i], arr[largest]);

heapify(arr, n, largest);
}
}
```
```

### 2. Iterative Approach:

The iterative approach involves using a loop to perform the same operations as the recursive approach but without recursion.

``````
void heapify(int arr[], int n, int i) {
while (true) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])
largest = left;

if (right < n && arr[right] > arr[largest])
largest = right;

if (largest == i)
break;

swap(arr[i], arr[largest]);
i = largest;
}
}
```
```

## Conclusion

Heapify is a crucial operation in data structures, specifically for binary heaps. It ensures the heap property is maintained, allowing efficient insertion, deletion, and building of heaps. Understanding the heapify algorithm and its implementation is essential for working with heaps effectively.