Heapify
=======

Suppose you have the following array:

    2 1 3 4 5 6

What is the result of "heapifying" it using the algorithm just
presented?

a.  `6 5 3 1 4 2`
b.  `5 4 6 2 1 3`
c.  *`6 5 3 4 1 2`*
d.  `6 4 5 2 3 1`

Where to heapify
================

Suppose we started `heapify` at the last element in the heap, rather
than at `(size - 1) / 2`. What would be the result?

a.  the algorithm would now be $O(n^2)$
b.  *we'd do more work but not change the outcome*
c.  the resulting array would not be a heap
d.  the left subtree would be a heap, but not the right subtree

`split` worst case
==================

Quick sort's runtime depends upon how well `split` works. What's the
worst case for `split`?

a.  `firstIndex + 1 == lastIndex`
b.  `split` is always linear (O(n)), so it doesn't matter
c.  *when the chosen `splitValue` is the min or max value in the range
    (`firstIndex`, `lastIndex`)*
d.  when the chosen `splitValue` is the median value in the range
    (`firstIndex`, `lastIndex`)

min/max lower bound
===================

Suppose I have done n-2 comparisons among my n elements, and I claim
that element x is the maximum. Why must I be wrong in the worst case?

a.  *another element y has never been found smaller than any other
    element*
b.  x must have been found smaller than at least one other element
c.  there must be an element that has never been compared to any other
    element
d.  only a binary tournament can find the max