• Fibonacci Heaps, chapter 20.

• Accelerated Binomial Heaps, binomialHeapA.h

• amortized analysis, chapter 17, scan only

• Binomial Heaps, chapter 19.

• red-black trees, chapter 13.

• binary search trees, chapter 12, scan only

• B-trees, chapter 18.

• Hash tables, chapter 11.

• basic data structures, chapter 10, scan only

• medians, randomized and deterministic select, chapter 9

• combining sort methods, sort/introspectiveSort.h

• a sorting lower bound, chapter 8.1.

• heapSort, chapter 7.

• quickSort, randomized quickSort, chapter 6.

• Master Theorem (statement and use), 4.3

• solving recurrences with recursion tree method, chapter 4.2

• solving recurrences with substitution method, chapter 4.1

• merge sort, chapter 2.3.

• insertion sort, chapter 2.2.

• minimal distance between points, chapter 33.4

• minimum in n-1 comps, max and min together in about 3n/2 comps, chapter 9.1.

Questions are likely to be "affinity" questions or "compare and contrast" questions.

1. What do these three items all have in common. What aspects do two of them share but the third not?

   mergesort, heapsort, and quicksort

2. of an algorithm, it's

   worst case time, average case time, expected time

3. randomized-select, randomized-quicksort, introspective-sort

1. All three are O(n*lg(n)) sorting algorithms (if you take average case time for quicksort).

   Merge and heap share O(n*lg(n)) worst case time.

   heap and quick share being in place, i.e. O(1) extra memory.

   merge and quick share being divide and conquer algorithms.

   ...

2. All three concern considering all inputs of a given size n. and estimating something about the times used by algorithm on all those inputs of size n.

   expected and worst case share being applicable randomized algorithms

   average and worst case share being applicable to normal deterministic algorithms.

   expected and average share being averages of a set of many times, whereas worst case is about an extreme in the set of times. This is since expected time is average over not only the inputs of size n, but also over the set of all possible random sequences of bits used by the algorithm.

3. all three use randomized-partition.

   rqsort and introsort share being sorting algorithms and having the same expected run time, which is O(n*lg(n)),

   rsel and rqsort share having worst case run time of O(n²).

   rsel and intro share nothing I can think of that rqsort doesn't also share. I suppose both can be considered to be variations stemming from rqsort. rsel is almost identical to rqsort except that you recursively process only one half of the partition instead of both. introsort is almost identical to rqsort except that you turn to insertion sort if the size gets low (around 16) and you turn to heapsort if the recursion depth gets too deep. It is this latter property that gives introsort O(n*lg(n)) worst case time.

Generally we are very forgiving of awkward modes of expression as referred to in (3). However there is a close correlation between clear thinking and clear expression and I urge you to put effort into ways of expressing points clearly and precisely.