Assignment 5  due Thursday, October 10
at the beginning of lab
CS 5521 Fall Semester, 2013
20 Points
Topics: Quicksort, randomized quicksort, and their run times
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 (15 points)
Implement the following three sorting routines:
 heapsort (page 160) 
actually, you should implement "minheapsort" that sorts in decreasing
order, which is easy to do with the minHeapify() routine of the previous
assignment.
Rather than implementing accessors and mutators (which is good
software engineering), declare the member variables
(the array A[],
length, and
heapSize) to be public so that heapsort is not slowed down
by accessor/mutator function calls.

quicksort (page 171), and

randomizedquicksort (page 179).
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 worstcase 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)

heapsort

quicksort

randomized quicksort
Compare the results  which is fastest? slowest?
Discussion: for randomizedquicksort,
you can use the C library routine
rand()
to get a (pseudo) random number (int) in the range 0 to
RAND_MAX (e.g.
RANDOM(p,r) could just return
p + rand() % (r  p + 1)
 or, better: change Line 1 of
RANDOMIZEDPARTITION()
to
i = p + rand() % (r  p + 1) ).
Note:
rand()
and
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)
 (5 points) Exercise 7.42, page 184.
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,n1].
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.
This shows that quicksort is Ω(n lg n) in the best case.
Using the Fact: f(q) = q lg q + (aq) lg (aq) attains its
minimum at q = a/2 (and substituting n1 for a), we have
T(n) ≥ c(n1) lg((n1)/2) + Θ(n)
= cn lg(n1)  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_{1}n for some c_{1} > 0.
Don't forget to prove the Fact.
Page URL: http://www.d.umn.edu
/~ddunham/cs5521f13/assignments/a5/assignment.html
Page Author: Doug Dunham
Last Modified: Thursday, 03Oct2013 21:23:45 CDT
Comments to: ddunham@d.umn.edu