Scribd
Upload
25 views

Analysis of Recursive Algorithms

Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It has average case performance of O(nlogn) but worst case of O(n^2) if the pivot selection is poor. Strassen's matrix multiplication improves on the naive O(n^3) matrix multiplication algorithm, achieving O(n^2.807) performance by strategically breaking the problem into smaller subproblems. The Master Theorem can be applied to analyze divide and conquer recurrences like those for Quicksort and Strassen's algorithm.

Uploaded by

Salman Khan
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
25 views

Analysis of Recursive Algorithms

Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It has average case performance of O(nlogn) but worst case of O(n^2) if the pivot selection is poor. Strassen's matrix multiplication improves on the naive O(n^3) matrix multiplication algorithm, achieving O(n^2.807) performance by strategically breaking the problem into smaller subproblems. The Master Theorem can be applied to analyze divide and conquer recurrences like those for Quicksort and Strassen's algorithm.

Uploaded by

Salman Khan
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 9

Analysis of Recursive

Algorithms

Quick Sort Algorithm


QuickSort(A, left, right) {
if (right > left) then {
pivot = Partition(A, left, right);
QuickSort(A, left, pivot-1);
QuickSort(A, pivot+1, right);
}
}

Partition Algorithm

Partition(a[ ], left, right ) {


int i, j;
int Pivot = (left+right) / 2;
Swap(A[Pivot], A[right]);
i = left; j = right - 1;
Pivot = right;
while ( i < j ) {
while( a[ i ] <= a[Pivot]) i++;
while( a[ j ] >= a[Pivot]) j- -;
if ( i < j ) SWAP(a[i], a[ j ]);
}
Swap(A[ i ], A[Pivot])
return i
}

Analysis of Quick Sort


For analysis assume a random pivot (no
median-of-three partitioning) and no cutoff for
small files.
T(0) = T(1) = 1
T(n) = Running time of two recursive calls
+ linear time spent in partition and constant
time per pivot selection.
T(n) = T(i) + T(n i 1) + cn
Where i = |S1| is the number of elements in
S1

Worst-Case Analysis of Quick Sort


The pivot is the smallest element all the
time. Then
i = 0 and if we ignore T(0) = 1, which is
insignificant, the recurrence is
T(n) = T(n 1) + cn, n > 1
We telescope this equation thus
T(n 1) = T(n 2) + c(n 1)
T(n 2) = T(n 3) + c(n 2)

T(2) = T(1) + c(2)


Adding up all these equations yields
n

T (n) = T (1) + c i = O( n 2 )
i =2

Best-Case Analysis of Quick


Sort
In the best case, the pivot is in the middle.
To simplify math, we assume that
Two subfiles are each exactly half the size of the
original, although this gives
Slight overestimate, but this is acceptable because
we are only interested in a Bih-Oh answer.

T(n) = 2T(n/2) + cn.


The same recurrance yields by Merge Sort
therefore
T(n) = cnlgn + n = O(nlg n)

Master Theorem
The solution to the equation
T(n) = aT(n/b) + (nk), where a >= 1
and b >1 is

T(n)

O(nlogb a)
O(nklogn)
O(nk)

if a > bk
if a = bk
if a < bk

Solve the following recursion for the


Strassens Matrix Multiplication
Algorithm
T(n) = 8T(n/2) + O(n2)

Strassens Matrix Multiplication


Recurrence
Solve the following recurrence using
Master Theorem
T(n) = 8T(n/2) + O(n2)
a = 8, b = 2,
k=2
a > bk, 8 > 22

lg2 8

T(n) = O(n ) = O(n )

You might also like