Heapsort

• I'm going to start to jump around a bit.
• This week I'd like to do my best to finish our look at sorting.
• Heapsort, Limits on Sorting, Bin/Radix sort.
• A priority queue is a collection of data items with an order, by priority.
  • The operations are insert and remove highest priority.
  • You saw a priority queue in Prim's and Dijkstra's.
  • We have an expectation for O(lg(n)) performance for the operations on a priority queue.
• We will implement a priority queue using a heap.
• A heap is a binary tree with two properities
  • It is a nearly complete tree. Ie all levels except the last are full (level i has 2ⁱ nodes)
  • At each node, the key values of ALL of the descendant nodes are less than the key value of the node.
  • The path from the root to ANY leaf contains decreasing key values!
  • There is no relationship between sibling nodes, or nodes in other subtrees.
  • Draw examples of heaps and non heaps for the numbers between 0 and 20
• He lists some properties of a heap
  • The exists exactly one essentially complete binary tree with n nodes. The height of this tree is O(lg(n))
  • The root of a heap always contains the largest element.
  • A node of a heap considered with all of its descendants is also a heap.
• An array based implementation of a heap.
  • We will use the indexes to represent the edges.
  • Position 0 is unused.
  • The root is at position 1
  • A left child of node n will be at 2n
  • A right child of node n will be at 2n+1
  • A parent of node n will be at ⌊n/2⌋
• I'm going to use CLRS's algorithms now.
  • LEFT(i) return 2i
  • RIGHT(i) return 2i+1
  • PARENT(i) return i/2
  • Assume we maintain a value heap-size
  • MAX_HEAPIFY
    • MAX_HEAPIFY assumes that the children of i are heaps, but the heap at I might not be.
    • IE: the value at position i might need to be moved down.

    • MAX_HEAPIFY(A,i)
      
       l ← LEFT(i)
       r ← RIGHT(i)
       if l ≤ heapSize and A[l] > A[i]  then
           largest ← l
       else 
           largest ← i
       if r ≤ heapSize and A[r] > A[largest]  then
           largest ← r
       if largest ≠ i then
           exchange(A[i],A[largest)
           MAX_HEAPIFY(A, largest)
      
      	

    • Does it terminate?
    • Does it work?
      • Observe
      • Since the two subtrees were heaps, then after the routine, node i will hold the largest value.
      • The subtree not "selected" will still not be changed, so it will still be a heap, and the parent of this node (i) will have a larger key value than all elements in this subtree.
      • The subtree "selected" may not be a heap, but this is fixed in line 10.
    • Performance
      • Look at a tree with 5 nodes.
      • The split can be as bad as 2n/3
      • So T(n) = T(2n/3) + O(1)
      • But the master method (a=1, b=2/3,n=0)
        • a = b^d (1 = (2/3)⁰)
        • So the algorithm is O(lg (n))
  • Now to construct a heap. Assume A is an unordered array with elements at position 1 through n

    • BUILD_MAX_HEAP(A)
      
        heap-size ← n
        for i ← n/2 down to  1 do
             MAX_HEAPIFY(A,i)
      
      	

    • Terminate?
    • Work
      • We need to argue that at each stage the subheaps will be subheaps
      • Will they be?
    • Time?
      • A lazy analysis yields O(n lg(n))
      • A tighter analysis (in the book) yields O(n)
  • Finally heapsort

    • HEAP_SORT(A)
      
       heap-size = n
       BUILD_MAX_HEAP(A)
       fori← n down to 2
           exchange(A[i],A[1])   // move the biggest to the end of the array
           heap-size ← heap-size - 1
           MAX_HEAPIFY(A,1)
      
      	    

    • Does it terminate?
    • Does it work? Why?
    • Time?