When it comes to data structures, the heap is a commonly used one. But have you ever wondered what data structure the heap itself uses?

## Introduction to Heap

A heap is a specialized tree-based data structure that satisfies the heap property. The heap property states that for any given node in the tree, its value 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 nodes.

### Heap Operations

The two main operations performed on a heap are __insertion__ and __deletion__. When an element is inserted into a heap, it is placed in the next available spot in the tree and then “bubbled up” or “sifted up” to its correct position based on the heap property. On the other hand, when an element is deleted from a heap, it is usually removed from the root node and then “bubbled down” or “sifted down” to its correct position.

## The Underlying Data Structure of Heap

The underlying data structure used by heaps is typically an **array**. Yes, you read that right – an array! The tree-like structure of heaps can be efficiently represented using an array.

### Heap as an Array

In order to represent a complete binary tree (which heaps are), we can use an array where each index corresponds to a node in the tree. The root node will be stored at index 0, and for any given node at index i:

- The left child can be found at index 2i + 1.
- The right child can be found at index 2i + 2.
- The parent can be found at index (i – 1) / 2.

Using this array representation, we can easily navigate through the heap and perform the necessary operations. This is one of the reasons why heaps are efficient data structures for tasks such as priority queues and heapsort.

### Heapify

When constructing a heap from an array, a process called *heapify* is performed. Heapify rearranges the elements in the array to satisfy the heap property. It starts from the last non-leaf node and works its way up to the root node, ensuring that each subtree rooted at a node satisfies the heap property.

## Conclusion

In conclusion, heaps are tree-based data structures that use arrays as their underlying data structure. The ability to efficiently represent a complete binary tree using an array makes heaps a powerful tool for various applications. Understanding this underlying data structure helps in implementing and utilizing heaps effectively.

Now that you know what data structure the heap uses, you can delve deeper into understanding how heaps work and explore their applications in more detail.