CS201 - Spring 2014 - Class 27

  • look at ArrayListPriorityQueue class in PriorityQueue code

  • heapify
       - called on a node (in the code, this is specified by providing the index of that node)
       - assumes both children of that node are valid heaps (or null)
       - HOWEVER, the current node/subtree is not a heap
       - turns the subtree at the current node into a heap
          - recursively moves the current value down

  • Building a heap: given n data items, how can we build a heap?
       - the easy version:
          - call add n times
          - what is the run-time?
             - n calls to add
             - each call to add is O(log n)
             - O(n log n)
       - can we use our heapify method?
          - heapify requires that the left and right children are valid heaps
          - Any way to accomplish this easily?
             - single element heaps are trivially valid heaps
          - basic idea:
             - start with n/2 single element heaps
             - slowly build up bigger and bigger heaps
             - for example:
                - let's say we want to build a heap from 1-7 in some random order, say:
                   - 1, 5, 6, 3, 4, 2, 7
                - what does this look like as a heap/tree?
                - is it a valid heap? No!
                - are any of the sub-tree/sub-heaps valid heaps?
                   - all of the leaves are!
                - Does this help us (think heapify)?
                   - call heapify on all of the nodes above the leaves
                   - repeat!
             - look at constructor in ArrayListPriorityQueue class in PriorityQueue code
                - we let the end n/2 elements in the data item be the single element heaps
                - work our way from n/2 to the front of the data
                - since we know that everything with an index > than the current index is a valid heap, each call to heapify will generate a valid heap
          - run-time?
             - n/2 calls to heapify
             - easy answer is O(n log n), since each call to heapify is O(log n)
             - however, a lot of the early calls to heapify are not O(log n), for example the first n/4 calls are just O(1) since there is at most one swap that can happen
             - with a little bit of math, you can show that it actually is O(n) to construct a heap using this approach (follow the line of reasoning above and you'll get: \sum_i=1^(log n) (n i)/(2^(i+1)), which works out to O(n)

  • could we use a heap to sort data?
       - build a heap with our data
       - call extractMin n times
       - what is the runtime?
          - O(n) to build the heap
          - n calls to extractMin = O(n log n)
          - O(n log n) overall
       - this is called heap-sort and is another O(n log n) time algorithm for sorting data

  • can we do better than O(n log n) for sorting?

  • binary heaps in summary
       - binary heaps allow us to insert and extract the minimum values in O(log n) time
       - http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html

    •