为什么堆排序的时间复杂度是 O(nlogn)？

Question

I'm trying to understand time complexity of different data structures and began with heap sort. From what I've read, I think collectively people agree heap sort has a time complexity of O(nlogn); however, I have difficulty understanding how that came to be.

Most people seem to agree that the heapify method takes O(logn) and buildmaxheap method takes O(n) thus O(nlogn) but why does heapify take O(logn)?

From my perspective, it seems heapify is just a method that compares a node's left and right node and properly swaps them depending if it is min or max heap. Why does that take O(logn)?

I think I'm missing something here and would really appreciate if someone could explain this better to me.

Thank you.

Answer 1

It seems that you are confusing about the time complexity about heap sort. It is true that build a maxheap from an unsorted array takes your O(n) time and O(1) for pop one element out. However, after you pop out the top element from the heap, you need to move the last element(A) in your heap to the top and heapy for maintaining heap property. For element A, it at most pop down log(n) times which is the height of your heap. So, you need at most log(n) time to get the next maximum value after you pop maximum value out. Here is an example of the process of heapsort.

          18 

      15        8  

   7     11   1    2  

 3   6 4    9

After you pop out the number of 18, you need to put the number 9 on the top and heapify 9.

          9

      15       8

   7     11  1   2

 3   6 4

we need to pop 9 down because of 9 < 15

             15

          9       8

       7     11  1   2

     3   6 4

we need to pop 9 down because of 9 < 11

          15

      11       8

   7     9  1   2

 3   6 4

9 > 4 which means heapify process is done. And now you get the next maximum value 15 safely without broking heap property.

You have n number for every number you need to do the heapify process. So the time complexity of heapsort is O(nlogn)

Answer 2

You are missing the recursive call at the end of the heapify method.

Heapify(A, i) {
   le <- left(i)
   ri <- right(i)
   if (le<=heapsize) and (A[le]>A[i])
      largest <- le
   else
      largest <- i 
   if (ri<=heapsize) and (A[ri]>A[largest])
      largest <- ri
   if (largest != i) {
      exchange A[i] <-> A[largest]
      Heapify(A, largest)
   }
}

In the worst case, after each step, largest will be about two times i . For i to reach the end of the heap, it would take O(logn) steps.