The assignment: consists of two parts: In the first part, you are asked to implement quicksort, randomized quicksort, and heapsort, and compare their running times with merge sort;. in the second part, you are asked to prove a fact about the run time of quicksort.

Part 1: Comparing the run times of sorting routines (10 points)

After you have coded all three of the sort routines, load the array A with the integers 1, 2, ..., n in order, i.e., A[i] = i. This should produce worst-case performance for quicksort; the run times of the other two sorts should by independent of the order of the input. Make timing runs for each of the sorts for the largest value of n that you used for merge sort in Assignment 2 and record the times for each of the four sorts: merge sort (from Assignment 2) and the three new ones. Compare the results -- which is fastest? slowest?

Discussion: for randomized-quicksort, you can use the C library routine rand() to obtain (pseudo-) random number (int) in the range 0 to RAND_MAX (for example, RANDOM(p,r) could simply return   p + rand() % (r - p + 1) -- or, better: replace Line 1 of RANDOMIZED-PARTITION() with   i <- p + rand() % (r - p + 1) ). Note: rand() & RAND_MAX are declared in <stdlib.h>.

What To Hand In: The results of your timing runs and the code for each of your new sort routines.

Part 2: Proving a fact about quicksort's run time (5 points)

• (4 points) Exercise 7.4-2, page 159. Similarly to Section 7.4.1, we want to solve the recurrence:
          T(n) = min ( T(q) + T(n - q - 1) ) + Θ(n)
  where the minimum is taken over q in [0,n-1]. The problem suggests that T(n) ≥ cnlg(n), which can be shown to be true by the substitution method for a suitable value of c. Using the Fact: f(q) = q lg q + (a-q) lg (a-q) attains its minimum at q = a/2 (and substituting n-1 for a), we have
          T(n) ≥ c(n-1) lg((n-1)/2) + Θ(n)
                  = cn lg(n-1) - c( lower order terms in n ) + Θ(n)
                  ≥ cn lg(n/2) - c( lower order terms in n ) + Θ(n) (for what n?)
                  = cn lg n - c( new lower order terms in n ) + Θ(n)
                  ≥ cn lg n
  for a suitable value of c (how should it be chosen?). You can assume the Θ(n) term can be replaced by c₁n for some c₁ > 0. Don't forget to prove the Fact.