- Recall the
Quick Sort Algorithm:
/* ======================================================== Sort: a[iLeft] a[iLeft+1] .... a[iRight-1] ======================================================== */ void QuickSort( double[] a, int iLeft, int iRight ) { if ( iRight - iLeft ≤ 1 ) { // An empty array or an array of 1 element don't need sorting ! return; } k = partition( a, iLeft, iRight ); // Returns the pos. of pivit after partitioning QuickSort( a, iLeft, k ); // Sort left half of partitioned array QucikSort( a, k+1, iRight); // Sort right half of partitioned array }
- Fact:
- The running time of
the Quick Sort Algorithm
depends
on how
the partition()
method will
split the
input array
- Since the
partition()
method depends on
the pivot,
we conclude that:
- the value of the pivot will affect the performance of Quick Sort...
- The running time of
the Quick Sort Algorithm
depends
on how
the partition()
method will
split the
input array
- Fact:
- The Quick Sort algorithm
performs the
worst when
the pivot is the
largest or
smallest value
in the array
- Reason:
- When the pivot is the largest or smallest value in the array, the partition() step will do nothing to improve the ordering of the array elements
Example:
Observation:
- Suppuse the
input array has
n elements.
If the pivot is the largest or smallest value in the array, the partition() step will result:
- One of the arrays (left[] or left[] ) will have n−1 elements
- The other array will have 0 (zero) elements
- The Quick Sort algorithm
performs the
worst when
the pivot is the
largest or
smallest value
in the array
- The Quick Sort Algorithm will perform
the worst when:
- Each time the Quick Sort performs the partition() on the input array, the pivot selected is the smallest/largest value in the array
- Here is an (small) example that
shows that
this can
happen:
Before sort: [2.5, 8.9, 1.1, 4.2, 9.2] Input: [2.5, 8.9, 1.1, 4.2, 9.2] a[] = [2.5, 8.9, 1.1, 4.2, 9.2] Pivot = 9.2 After partition: [4.2, 2.5, 8.9, 1.1, 9.2] Input: [4.2, 2.5, 8.9, 1.1] a[] = [4.2, 2.5, 8.9, 1.1, 9.2] Pivot = 1.1 After partition: [1.1, 4.2, 2.5, 8.9, 9.2] Input: [] a[] = [1.1, 4.2, 2.5, 8.9, 9.2] Done. Input: [4.2, 2.5, 8.9] a[] = [1.1, 4.2, 2.5, 8.9, 9.2] Pivot = 8.9 After partition: [1.1, 2.5, 4.2, 8.9, 9.2] Input: [2.5, 4.2] a[] = [1.1, 2.5, 4.2, 8.9, 9.2] Pivot = 4.2 After partition: [1.1, 2.5, 4.2, 8.9, 9.2] Input: [2.5] a[] = [1.1, 2.5, 4.2, 8.9, 9.2] Done.I have highlighted the pivots in each partition() call.
- Worst case running time
analysis of Quick Sort:
/* ======================================================== Sort: a[iLeft] a[iLeft+1] .... a[iRight-1] ======================================================== */ void QuickSort( double[] a, int iLeft, int iRight ) { if ( iRight - iLeft ≤ 1 ) { // An empty array or an array of 1 element don't need sorting ! return; } k = partition( a, iLeft, iRight ); // Worst case: ONE array has (n-1) elements // the OTHER array has 0 elements QuickSort( a, iLeft, k ); // Sort left half of partitioned array QucikSort( a, k+1, iRight); // Sort right half of partitioned array }Summary of the execution:
QuickSort( input array with n elements ) { .... partition( a (array with n elements) ); QuickSort( array with (n-1) elements ); QuickSort( array with 0 elements ); }
- Therefore:
Amount of work done by QuickSort( array of size n ) = Amount of work done by partition ( array of n elements ) + Amount of work done by QuickSort( array of size n-1 ) + 0
Or: T(n) = partition(n) + T(n-1) Where: T(n) = Amount of work done by QuickSort( array of size n )
- Amount of work done by
partition( array of n elements):
- Consider the
partition( )
algorithm:
public static int partition( double[] a, int iLeft, int iRight ) { double pivot; double help; int smaller_I, larger_I; smaller_I = iLeft; larger_I = iRight-1; // larger_I - smaller_I // = iRight - iLeft - 1 // = n - 1 (n = # elems in array) pivot = a[iRight-1]; while ( larger_I > smaller_I ) // <==> larger_I - smaller_I > 0 { if ( a[larger_I -1] > pivot ) { /* ================================================== Put a[larger_I -1] in the hole and move hole down ================================================== */ a[larger_I] = a[larger_I -1]; larger_I--; } else { /* ================================================= a[larger_I -1] <= pivot, so: Swap a[smaller_I] with a[larger_I -1] and move smaller_I up ================================================= */ help = a[larger_I -1]; a[larger_I -1] = a[smaller_I]; a[smaller_I] = help; smaller_I++; } } a[larger_I] = pivot; // Put pivot in the "hole" return larger_I; }Observation:
- The variables
smaller_I
and
larger_I
starts out with:
larger_I - smaller_I = n - 1
- After each iteration of the
while-loop,
the difference of the
variables
larger_I - smaller_I
will
decrease by 1
- (Because one of these 2 things will happen:
larger_I--
or
smaller_I++.
- Either one will make the difference: larger_I - smaller_I decrease by 1)
- (Because one of these 2 things will happen:
larger_I--
or
smaller_I++.
- The variables
smaller_I
and
larger_I
starts out with:
- Conclusion:
- Running time of
partition( array of n elements )
is equal to:
- = (n − 1) (while loop) + 1 (copying the pivot back)
- = n
- Running time of
partition( array of n elements )
is equal to:
- Consider the
partition( )
algorithm:
- Therefore:
worst case performance
of Quick Sort
T(n) = partition(n) + T(n-1) // partition(n) = n = n + T(n-1) = T(n-1) + n T(1) = 1 // For the if-check operationSolving the recurrence relation:
T(n) = T(n-1) + n // T(n-1) = T(n-2) + (n-1) = T(n-2) + (n-1) + n = T(n-3) + (n-2) + (n-1) + n = ... = T(1) + 2 + 3 + ... + (n-1) + n // T(1) = 1 = 1 + 2 + 3 + ... + (n-1) + n n (n+1) = --------- 2
- Worst case performence
of Quick Sort:
n (n+1) T(n) = --------- = O(n2) 2(So Quick Sort is really "slow sort" in the worst case !!!)
- Fact:
- The Quick Sort
algorithm performs the
best
when the pivot is the
middle value in the
array
- In the best case, the input array is divided into 2 arrays each containing approximately n/2 element
- The Quick Sort
algorithm performs the
best
when the pivot is the
middle value in the
array
- Example:
- Best case running time
analysis of Quick Sort:
/* ======================================================== Sort: a[iLeft] a[iLeft+1] .... a[iRight-1] ======================================================== */ void QuickSort( double[] a, int iLeft, int iRight ) { if ( iRight - iLeft ≤ 1 ) { // An empty array or an array of 1 element don't need sorting ! return; } k = partition( a, iLeft, iRight ); // Best case: TWO array with n/2 elements QuickSort( a, iLeft, k ); // Sort left half of partitioned array QucikSort( a, k+1, iRight); // Sort right half of partitioned array }Summary of the execution:
QuickSort( input array with n elements ) { .... partition( a (array with n elements) ); QuickSort( array with n/2 elements ); QuickSort( array with n/2 elements ); }
- Therefore:
Amount of work done by QuickSort( array of size n ) = Amount of work done by partition( array of n elements ) + Amount of work done by QuickSort( array of size n/2 ) + Amount of work done by QuickSort( array of size n/2 )
Or: T(n) = partition(n) + T(n/2) + T(n/2) = partition(n) + 2*T( n/2 ) Where: T(n) = Amount of work done by QuickSort( array of size n )
- Amount of work done by
partition( array of n elements):
- From previous result----
running time of
partition( array of n elements )
is equal to:
- = (n − 1) (while loop) + 1 (copying the pivot back)
- = n
- From previous result----
running time of
partition( array of n elements )
is equal to:
- Therefore:
best case performance
of Quick Sort
T(n) = partition(n) + 2*T(n/2) // partition(n) = n = n + 2*T(n/2) = 2*T(n/2) + n T(1) = 1 // For the if-check operationSolving the recurrence relation:
T(n) = 2*T(n/2) + n // T(n/2) = 2*T(n/4) + (n/2) = 2*[ 2*T(n/4) + n/2 ] + n = 22*T(n/4) + n + n = 22*T(n/4) + 2n // T(n/4) = 2*T(n/8) + (n/4) = 22*[ 2*T(n/8) + (n/4) ] + 2n = 23*T(n/8) + 22*(n/4) + 2n = 23*T(n/8) + n + 2n = 23*T(n/8) + 3n = 24*T(n/16) + 4n and so on.... = 2k*T(n/(2k)) + k*n // Keep going until: n/(2k) = 1 <==> n = 2k = 2k*T(1) + k*n = 2k*1 + k*n = 2k + k*n // n = 2k = n + k*n = n + (lg(n))*n = n*( lg(n) + 1 ) ~= n*lg(n))
- Worst case performence
of Quick Sort:
T(n) = n*log(n)(So Quick Sort is indeed fast in the fast case !!!)
- It too difficult to
put the analysis in a webpage
form....
I have a hand-written derivation here: click here
- This is
the summary:
T(n) ~= 2(n+1) Hn+1 (Hn = n-th Harmonic number) = O( n*log(n) )
- My notes are based on this webpage: click here
- Here is a test program that
generates
N random numbers and
calls
Quick Sort to sort them....
- Example Program:
(Demo above code)
- The Quick Sort Prog file: click here
- The test Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: javac testProg.java
- To run: java testProg
- The test program shows you why people call this method Quick Sort !