**What Is Heapify in Data Structure With Example?**

In data structure, heapify is a process of rearranging the elements of a binary heap to maintain the heap property. A binary heap is a complete binary tree where every parent node is smaller (for min heap) or larger (for max heap) than its children. Heapify ensures that the root node has either the minimum or maximum value, depending on the type of heap.

## Heap Property

The heap property is a crucial concept in understanding how heapify works. In a min heap, for example, the value of each parent node is smaller than or equal to its children.

Conversely, in a max heap, each parent node has a value greater than or equal to its children. This property allows quick access to either the minimum or maximum element.

## The Process of Heapify

Heapify is typically performed on an array representation of a binary heap. The process involves two main steps: __sifting up__ and __sifting down__.

### Sifting Up

Sifting up, also known as **up-heapification**, is used when an element is inserted into the binary heap. It ensures that the newly added element maintains the correct order based on the defined heap property.

When an element is inserted at the bottom level of the tree (the last index in the array representation), it may violate the heap property. To restore it, we compare the newly added element with its parent and swap them if necessary. This process continues recursively until all levels are checked and no swaps are required.

### Sifting Down

Sifting down, also called **down-heapification**, is applied when an element is removed from the binary heap. After removal, the last element in the array is placed at the root position and may not satisfy the heap property.

To restore the heap property, we compare the new root with its children and swap it with the smaller child (in a min heap) or larger child (in a max heap). This process continues recursively until all levels are checked, and the heap property is maintained once again.

## Example of Heapify

Let’s consider an example to illustrate how heapify works:

We have an array representation of a min heap: [10, 15, 30, 40, 50, 100].

If we remove the minimum element (10) from the heap, we will be left with [15, 40, 30, 100, 50].

To restore the min-heap property using down-heapification:

- Compare the root (15) with its children (40 and 30).
- Swap it with the smaller child (30).
- Compare again with its new children (40 and 100).
- Swap it with the smaller child (40).
- The final result is [30, 40, 100]. The min-heap property is restored.

This example demonstrates how down-heapification ensures that after removal of an element from a min heap, we rearrange the remaining elements to maintain the required properties.

## Conclusion

Heapify is a crucial operation in data structures when dealing with binary heaps. It allows us to maintain order and quickly access either minimum or maximum values. Understanding sifting up and sifting down ensures that the heap property remains intact when elements are inserted or removed from the heap.

By using proper heapify techniques, you can efficiently implement heaps in your algorithms and solve a wide range of problems that require efficient access to extreme values.