Building a Heap in an array

• Heapify

  Heapify(A,i)
  (1) l = Left(i)
  (2) r = Right(i)
  (3) if l <= heap_size[A] and A[l] < A[i]
  (4)    then smallest = l
  (5)    else smallest = i
  (6) if r <= heapsize[A] and A[r] < A[smallest]
  (7)    then smallest = r
  (8) if smallest != i
  (9)    then swap(A[i],A[smallest])
  (10)        Heapify(A,smallest)
  

  • This is equivelent to the bubble down in the book.
• BuildHeap

  • Build_Heap(A)
    (1) heapsize[A] = lenght[A]
    (2) for i = floor(length[A]/2) downto 1
    (3)    Heapify(A,i)
        

  • Just build the subheaps in the array from the bottom up
  • An easy bound is O(n lg n), but this is not asymptotically tight.
  • A tighter bound is O(n), and is much more diffacult to argue
  • And doesn't matter any way, as we will see in a minute.
  • Trace this for A= { 9, 22, 17, 10, 84, 6, 2, 3, 5}
• Heapsort

  • Heapsort(A)
    (1) BuildHeap(A)
    (2) for i = length[A] downto 2
    (3)   exchange A[1] A[i]
    (4)   heapsize[A] = heapsize[A] - 1
    (5)   Heapify(A,1)
    	

  • Line (1) is O(n)
  • Line (2) is O(n)
  • Line (5) is O(lg n)
  • So the entire thing is O(n lg n)
  • Trace this for A= { 9, 22, 17, 10, 84, 6, 2, 3, 5}
• The Code
  • Here is my final sort code for you.
  • And a sample run of sort4 (quicksort) and sort 7 (heapsort)

  • Sort4 took 1 ticks, and 7853646 moves
    Sort7 took 3 ticks, and 38095906 moves
    Ratio: 4.85073
    Sort4 took 1 ticks, and 7904994 moves
    Sort7 took 3 ticks, and 38096806 moves
    Ratio: 4.81933
    Sort4 took 1 ticks, and 7903690 moves
    Sort7 took 3 ticks, and 38095760 moves
    Ratio: 4.82
    	

  • In the final analysis, heapsort does about 5 times the number of moves.
  • and is about 3 times slower.