The central task in the heapsort algorithm is restoring the heap after each
removal of the root element. This reheaping takes
*O*(*log*(*n*))
time, for a
total of
*O*(*nlog*(*n*))
time since there are n elements. It seem
counterintuitive that heap sort would be so efficient since building the
heap often increases the number of inversions in the array. In fact it is
not only
*O*(*nlogn*)
in the average case, but it is
*O*(*nlog*(*n*))
in all
cases, unlike quick sort, which is quadratic in the worst case.

To walk through the process again, moving an element up from node 1 takes
on the order of log(n) steps since there are log(n) levels in the tree that
the value may have to move through. Therefore heapsort will take
*O*(*nlog*(*n*))
time, sifting up to
*log*(*n*)
levels for each element sorted. Even though the
heap gets smaller as the array is sorted, it doesn't get smaller very fast.
Half the elements in the initial heap are in the leaves, and after being
exchanged with the root, each of them can be expected to move about
*log*(*n*)
levels back.