Runtime anaylsis of the Quick Sort algorithm

Running time of the Quick Sort algorithm:
The running time of Quick Sort depends on how partition( ) splits up the input array

Recall the partition(A, s, e) algorithm:

Input: [ 5 1 7 2 8 9 3 6 ] Result: [ 1 2 3 5 7 8 9 6 ] <-------> <------------> < 5 >= 5

Important fact:
The running time of Quick Sort depends on how large the 2 array halves are !

Recurrence relation for the running time of the Quick Sort algorithm

Suppose the partition(A, s, e) algorithm partitions the input as follows:

<------------------- n -------------------> Input: [ P .. .. .. .. .. .. .. .. .. .. .. ] Result: [ .. .. .. .. .. .. P .. .. .... .. .. .. .. ] <----- k -----> <----- n-k-1 ------>

Recall the Quick Sort algorithm:

public static > void sort(T[] A, int s, int e) // n = e-s { if ( e - s <= 1 ) // Base case return; int pivotLoc = partition(A, s, e); // Running time = n sort(A, s, pivotLoc); // Input size = k sort(A, pivotLoc+1, e); // Input size = n-k-1 }

Running time T(n) for input size n: T(n) = T(k) + T(n-k-1) + n

The best case running time of Quick Sort

The best case running time of the Quick Sort algorithm happens when:
The partition( ) algorithm always divides the input array into 2 equal halves

In this case, we have:

T(n) = T(k) + T(n-k-1) + n k = n/2 = T(n/2) + T(n/2-1) + n ~= 2 T(n/2) + n

which is the similar recurrence relation as the one in Merge Sort

We can solve it with telescoping and the result is:

Best case running time = nlog(n) which is: O(nlog(n))

The worst case running time of Quick Sort

The worst case running time of the Quick Sort algorithm happens when:
The partition( ) algorithm always divides the input array into (1) array containing the pivot and (2) an array with n-1 elements

In this case, we have:

T(n) = T(0) + T(n-1) + n = 0 + T(n-1) + n = T(n-1) + n

Solve the recurrence relation with telescoping:

T(n) = T(n-1) + n T(n-1) = T(n-2) + (n-1) = T(n-2) + (n-1) + n T(n-2) = T(n-3) + (n-2) = T(n-3) + (n-2) + (n-1) + n = ... = T(1) + 2 + 3 + 4 + ... + (n-1) + n T(1) = 0 = 0 + 2 + 3 + 4 + ... + (n-1) + n (Triangular sum) = n(n+1)/2 - 1 = O(n²) <--- Worst case running time

Example that makes Quick Sort achieve the worst case running time

When Quick Sort is used to sort a sorted array, it will result in the worst case running time of O(n²)

Example:

A[] = [ 1 2 3 4 5 6 7 8 ... ] ^ | pivot After partition(A, 0, n): A[] = [ 1 2 3 4 5 6 7 8 ... ] ^ | pivot And so on...

Because the pivot is always the smallest value, partition( ) will always produce:
An array containing the pivot
An array containing the other n-1 elements

Commonly used practice with Quick Sort

Commonly used practice when using Quick Sort:

Shuffle the input array randomly
(To ensure partition( ) will not always find the pivot as the first element)
Use Quick Sort of the shuffled input array

Note:
Quick Sort will achieve the average running time performance with a randomized input array
We will study the average running time of Quick Sort next

The average case running time of Quick Sort

Recall the recurrence relation for the running time of Quick Sort is:

T(n) = T(k) + T(n-k-1) + n where k = final pos of the pivot

Depending on the value of k, the recurrence relation for T(n) are:

T(n) = T(0) + T(n-1) + n if k = 0 T(n) = T(1) + T(n-2) + n if k = 1 ... T(n) = T(n-1) + T(0) + n if k = n-1

Each value of k is equally likely to occur, so we can take the average by:

T(n) = T(0) + T(n-1) + n if k = 0 T(n) = T(1) + T(n-2) + n if k = 1 ... T(n) = T(n-1) + T(0) + n if k = n-1 (average = sum/n) ---------------------------------------------------------------- nT(n) = (T(0) + ... + T(n-1)) + (T(n-1) + ... + T(0)) + n*n nT(n) = 2T(0) + 2T(1) + ... + 2T(n-1) + n*n T(n) = 2/n*T(0) + 2/n*T(1) + ... + 2/n*T(n-1) + n

Solution: T(n) = 2(n+1) H_n ~= 2(n+1)lg(n+1) = O(nlog(n))