TCP2101 Algorithm Design and Analysis Lab07 - Divide-and-Conquer

TCP2101 Algorithm Design and Analysis
Lab 7 Divide-and-Conquer
Learning Outcome
● Understand how Merge Sort works.
● Understand how Integer Multiplication works.
● Understand how to use Master Theorem to solve recurrence equation.
● Understand how Quick Select works.
1. [20 min] The following MergeSort algorithm is used to sort the array of 7 integers below.
Array: 96 48 91 94 31 77 2
Input Parameters: array a, start index p, end index r.

Output Parameter: array a sorted.
Mergesort (a, p, r) {
// stop if only one element.
if (p < r) {
// Divide: divide a into two nearly equal parts.
m = (p + r) / 2
// Recur: sort each half.
Mergesort (a, p, m)
Mergesort (a, m + 1, r)
// Conquer: merge the two sorted halves.
Merge (a, p, m, r)
}
}
Fill in the table below based on the end of each Merge.

Array: 96 48 91 94 31 77 2
p r Array
0 1 48 96 91 94 31 77 2
2 3 48 96 91 94 31 77 2
0 3 48 91 94 96 31 77 2
4 5 48 91 94 96 31 77 2
4 6 48 91 94 96 2 31 77
0 6 2 31 48 77 91 94 96
The following C++ program shows the incomplete MergeSort algorithm. Implement and complete the program in
CodeBlocks. Compare the output of the program with the above table, is it the same?
// filename: mergesort.cpp
#include <iostream>
using namespace std;
void printArray (int A[], int n) {

for (int i = 0; i < n; ++i)
cout << A[i] << ' ';
cout << endl;
}
void merge (int A[], int Temp[], int p, int m, int r) {

int i, j;
for (i = m + 1; i > p; i--)
Temp[i - 1] = A[i - 1];
1
for (j = m; j < r; j++)
Temp [r + m - j] = A[j + 1];
for (int k = p; k <= r; k++)

if (Temp[j] < Temp [i])
A[k] = Temp[j--];
else
A[k] = Temp[i++];
}
void mergesort (int A[], int Temp[], int p, int r) {

// Put your code here!
if (p < r) {
// Divide: divide a into two nearly equal parts.
int m = (p + r) / 2;
// Recur: sort each half.
mergesort (A, Temp, p, m);
mergesort (A, Temp, m + 1, r);
// Conquer: merge the two sorted halves.
merge (A, Temp, p, m, r);
}
void startMergeSort (int A[], int n) {

int* Temp = new int[n];
mergesort (A, Temp, 0, n-1);
delete [] Temp;
}
int main() {
// Put your code here!
const int n = 7;
int A[n] = {96, 48, 91, 94, 31, 77, 2};
cout << "Original Array: \n";
printArray(A, n);
startMergeSort(A, n);
cout << "Sorted Array: \n";
printArray(A, n);
return 0;
2
2. [20 min] Use the Improved Integer Multiplication technique to multiply 91x53. Assume that the processor can
efficiently multiple integer with single digit or 10 only. Use base 10 for the simplicity of human calculation.
I = Ih*10n/2 + Il
J = Jh*10n/2 + Jl
I*J = Ih*Jh*10n + [(Ih- Il)(Jl - Jh) + Ih*Jh + Il*Jl]10n/2 + Il*Jl
n = 2
lh = 9
Il = 1
Jh = 5
Jl = 3
Lh *Jh = 9*5 = 45
Il *Jl = 1*3 = 3
(Ih-I1)(J1 - Jh) = (9-1)(3-5) = 8(-2) = -16
91 x 53
= Ih*Jh*10n + [(Ih- Il)(Jl - Jh) + Ih*Jh + Il*Jl]10n/2 + Il*Jl
= 45*10^2 + [-16 + 45 + 3]10 + 3
= 4500 + [32]10 + 3
= 4500 + 320 + 3
= 4823
3
3. [40 min] Use Master Theorem to find the time complexity T(n) for the following recurrence equations.
Case 1: <
Case 2: =
Case 3: >
a) T(n) = 2T(n/2) + n2log n b) T(n) = 8T(n/2) + n3 c) T(n) = 16T(n/2) + (n log n)4
f(n) = n2log n f(n) = n3 f(n) = n4log4 n

n^logb a = n^( log2 2) = n^1 n^logb a = n^( log2 8) = n^3 n^logb a = n^( log2 16) = n^4
Case 3: n2log n > n^1 Case 2: n3 logk n where k = 0 Case 2: n4log4 n = n^4
Case 2 because we can make these
T(n) = n2log n T(n) = n3 logk+1 n = O(n3 log n) two equal where n4log4 n = n4 logk
where k =4
T(n) = n4 logk+1 n = O(n4log5 n)
d) T(n) = 7T(n/3) + n e) T(n) = 9T(n/3) + n3log n f) T(n) = 9T(n-1) + log n
f(n) = n f(n) = n3log n f(n) = log n

n^logb a = n^( log3 7) = n^1.77 n^logb a = n^( log3 9) = n^2 n^logb a = Master method cannot
solve this because there are more
Case 1: n1 < n^1.77 Case 3: n3log n > n^2 than 1 answer. (Tn is not in the
form of a T(n/b) + f(n)
T(n) = O(n^1.77) T(n) = n3log n
T(n) = log n
4. [30 min] The following Quick-Select algorithm is used to find the k-th smallest element in the array below.
The pivot is selected from the last element of the current subarray. Assume the Partition function is stable.
Array: 31, 77, 4, 96, 42, 94, 55, 91, 66
Algorithm QuickSelect (a, p, r, k)

Input Parameters: array a, start index p, end index r,
target index k.
Output Parameter: a[k] at the correct position.
if (p <= r)
pi = Partition (a, p, r) // pivot index.
if (k == pi)
return a[pi]
if (k < pi)
QuickSelect (a, p, pi - 1, k)
else
QuickSelect (a, pi + 1, r, k)
(a) Use Quick-Select to find the 4th smallest element in the array. Fill in the table below based on the end of
each call to partition.
k = ___3_____.
31, 77, 4, 96, 42, 94, 55, 91, 66

p r p <= r Pivot Array after Partition pi k is equal to (=),
smaller (<) or
larger (>) than pi
0 8 True 66 31 4 42 55 66* 77 96 94 91 4 k < pi
0 3 True 55 31 4 42 55* 66 77 96 94 91 3 k = pi
4
th
The 4 smallest element = ___55_____.
(b) Use Quick-Select to find the 7th smallest element in the array. Fill in the table below based on the end of
each call to partition.
k = ____6____.
p r p <= r pivot Array after Partition pi k is equal to (=),

smaller (<) or
larger (>) than pi
0 8 True 66 31 4 42 55 66* 77 96 94 91 4 k > pi
5 8 True 91 31 4 42 55 66 77 91* 94 96 6 k = pi
th
The 7 smallest element = _____91______.
(c) What is the time complexity for Quick-Select algorithm?
T(n) = Theta(n)

TCP2101 Algorithm Design and Analysis Lab07 - Divide-and-Conquer

Uploaded by

TCP2101 Algorithm Design and Analysis Lab07 - Divide-and-Conquer

Uploaded by

TCP2101 Algorithm Design and Analysis

Input Parameters: array a, start index p, end index r.

Fill in the table below based on the end of each Merge.

void printArray (int A[], int n) {

void merge (int A[], int Temp[], int p, int m, int r) {

for (int k = p; k <= r; k++)

void mergesort (int A[], int Temp[], int p, int r) {

void startMergeSort (int A[], int n) {

a) T(n) = 2T(n/2) + n2log n b) T(n) = 8T(n/2) + n3 c) T(n) = 16T(n/2) + (n log n)4

f(n) = n2log n f(n) = n3 f(n) = n4log4 n

f(n) = n f(n) = n3log n f(n) = log n

Algorithm QuickSelect (a, p, r, k)

31, 77, 4, 96, 42, 94, 55, 91, 66

p r p <= r pivot Array after Partition pi k is equal to (=),

(c) What is the time complexity for Quick-Select algorithm?

You might also like