## Description

Problem 1.

Give the asymptotic upper bounds for T(n) in each of the following recurrences. Show your work

and explain how you solve each case.

Problem 1.a. (2 points)

• T(n) = b · T(n − 1) + 1 where b is a fixed positive integer greater than 1.

Problem 1.b. (2 points)

• T(n) = 3 · T(n/9) + n · log n

Problem 2. (6 points)

Solve Exercise 4.1-5 from the 3rd Ed. of the textbook.

Problem 3.

Consider the recurrence T(n) = 3 · T(n/2) + n.

Problem 3.a. (3 points)

• Use the recursion tree method to guess an asymptotic upper bound for T(n). Show your

work.

Problem 3.b. (3 points)

• Prove the correctness of your guess by induction. Assume that values of n are powers of 2.

Problem 4.

Consider the following pseudocode for a sorting algorithm, for 0 < α < 1 and n > 1.

badSort(A[0 · · · n − 1])

if (n = 2) and (A[0] > A[1])

swap A[0] and A[1]

else if (n > 2)

m = dα · ne

badSort(A[0 · · · m − 1])

badSort(A[n − m · · · n − 1])

badSort(A[0 · · · m − 1])

1

Problem 4.a. (3 points)

• Show that the divide and conquer approach of badSort fails to sort the input array if α ≤ 1/2.

Problem 4.b. (2 points)

• Does badSort work correctly if α = 3/4? If not, why? Explain how you fix it.

Problem 4.c. (2 points)

• State a recurrence (in terms of n and α) for the number of comparisons performed by badSort.

Problem 4.d. (2 points)

• Let α = 2/3, and solve the recurrence to determine the asymptotic time complexity of badSort.

Problem 5.

Problem 5.a. (3 points)

• Implementation: Implement badSort from Problem 4 to sort an array of integers. The value

of α should be an input parameter to your program. Implement the algorithm in C/C++.

Your program should be able to read inputs from a file called “data.txt”, where the first value

of each line is the number of integers that need to be sorted, followed by the integers. The

output will be written to a file called “bad.out”.

Problem 5.b. (3 points)

• Modify code: Modify the code to collect running time data. Call the new timing program

badSortTime. Instead of reading arrays from the file data.txt and sorting, you will now

generate arrays of size n containing random integer values from 0 to 10,000 to sort. Use

the system clock to record the running times of each algorithm for n = 5000, 10000, 15000,

20,000, . . . . for two values of α = 2/3 and α = 3/4. You may need to modify the values of

n if an algorithm runs too fast or too slow to collect the running time data. Provide a table

with the timing data.

Problem 5.c. (2 points)

• Plot data and fit a curve: Plot the running time data you collected for each value of

α ∈ {2/3, 3/4} on an individual graph with n on the x-axis and time on the y-axis. You

may use Excel, Matlab, R or any other software. How does your experimental running time

compare to the theoretical running time of the algorithm?

Problem 5.d. (2 points)

• Comparison: Looking at the plots in the previous step for α ∈ {2/3, 3/4}, which α provides

better performance?

Submit a copy of all your code files and a README file that explains how

to compile and run your code in a ZIP file to TEACH. We will only test

execution with an input file named data.txt.

2