# What Is Heapify Method in Data Structure?

//

Heather Bennett

The Heapify method is an important concept in data structures. It is primarily used to maintain and organize a heap data structure efficiently. In this article, we will explore what the Heapify method is and how it works.

## What is a Heap?

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

## Heapify Method

The Heapify method is used to create or restore the heap property in a given binary tree. It takes an array as input and rearranges its elements to satisfy the heap property.

The Heapify method can be applied in two scenarios:

### 1. Building a Heap

To build a heap from an array, we start with the last non-leaf node and perform the Heapify operation on each node in reverse order until we reach the root of the tree. This ensures that all nodes satisfy the heap property.

The pseudocode for building a max heap using Heapify method:

``````
procedure buildMaxHeap(arr):
n = length(arr)
for i = n/2 down to 1:
maxHeapify(arr, i, n)
``````

### 2. Restoring the Heap Property

After performing operations like insert or delete on a heap, there might be violations of the heap property. In such cases, we use the Heapify method to restore the property.

The pseudocode for restoring the max heap property using Heapify method:

``````
procedure maxHeapify(arr, i, n):
largest = i
left = 2*i
right = 2*i + 1

if left ≤ n and arr[left] > arr[largest]:
largest = left

if right ≤ n and arr[right] > arr[largest]:
largest = right

if largest ≠ i:
swap(arr[i], arr[largest])
maxHeapify(arr, largest, n)
``````

## Time Complexity

The Heapify method has a time complexity of O(log n), where n is the number of elements in the heap. This makes it an efficient method for maintaining and organizing a heap data structure.

## Conclusion

The Heapify method is a crucial operation in data structures. It allows us to build and maintain a heap efficiently. Understanding how the Heapify method works is essential for implementing heaps and optimizing algorithms that rely on this data structure.