Heap Sort is a popular and efficient sorting algorithm in computer programming. Learning how to write the heap sort algorithm requires knowledge of two types of data structures - arrays and trees.

The initial set of numbers that we want to sort is stored in an array e.g. `[10, 3, 76, 34, 23, 32]`

and after sorting, we get a sorted array `[3,10,23,32,34,76]`

.

Heap sort works by visualizing the elements of the array as a special kind of complete binary tree called a heap.

Consider the following algorithm for building a Heap of an input array A.

BUILD-HEAP(A) heapsize := size(A); for i := floor(heapsize/2) downto 1 do HEAPIFY(A, i); end for END

A quick look over the above algorithm suggests that the running time is O(nlg(n)), since each call to **Heapify** costs O(lg(n)) and **Build-Heap** makes O(n) such calls.

This upper bound, though correct, is not asymptotically tight.

We can derive a tighter bound by observing that the running time of **Heapify** depends on the height of the tree â€˜hâ€™ (which is equal to lg(n), where n is number of nodes) and the heights of most sub-trees are small.

The height â€™hâ€™ increases as we move upwards along the tree. Line-3 of **Build-Heap** runs a loop from the index of the last internal node (heapsize/2) with height=1, to the index of root(1) with height = lg(n). Hence, **Heapify** takes different time for each node, which is O(h).

For finding the Time Complexity of building a heap, we must know the number of nodes having height h.

For this we use the fact that, A heap of size n has at most \left \lceil \frac{n}{2^{h+1}} \right \rceil nodes with height h.

Now to derive the time complexity, we express the total cost of **Build-Heap**.

Step 2 uses the properties of the Big-Oh notation to ignore the ceiling function and the constant 2(2^{h+1} = 2.2^h). Similarly in Step three, the upper limit of the summation can be increased to infinity since we are using Big-Oh notation.

Sum of infinite G.P. (x < 1)

On differentiating both sides and multiplying by x, we get

Putting the result obtained in (3) back in our derivation (1), we get

Hence Proved that the Time complexity for Building a Binary Heap is O(n).