1

Quick-Sort
• To understand quick-sort, let’s look at a high-level description of the
algorithm
1) Divide : If the sequence S has 2 or more elements, select an element x
from S to be your pivot. Any arbitrary element, like the last, will do.
Remove all the elements of S and divide them into 3 sequences:
L, holds S’s elements less than x
E, holds S’s elements equal to x
G, holds S’s elements greater than x
2) Recurse: Recursively sort L and G
3) Conquer: Finally, to put elements back into S in order, first inserts
the elements of L, then those of E, and those of G.
Here are some pretty diagrams....

2
 Idea of Quick Sort
1) Select: pick an element

2) Divide: rearrange elements so

3) Recurse and Conquer:

3
Quick-Sort Tree

4
Quick-Sort Tree

5
Quick-Sort Tree

6
Quick-Sort Tree

7
Quick-Sort Tree

8
Quick-Sort Tree

9
Quick-Sort Tree

10
Quick-Sort Tree

11
Quick-Sort Tree

12
Quick-Sort Tree

13
Quick-Sort Tree

14
 Quick-Sort Tree

Skipping ... 15
... Finally

16
 In-Place Quick-Sort
Divide step: l scans the sequence from the left, and r from the right.

A swap is performed when l is at an element larger than the pivot and

17
 In Place Quick Sort (contd.)

A final swap with the pivot completes the divide step

18
 In Place Quick Sort code
public class ArrayQuickSort implements SortObject {
public void sort(Sequence S, Comparator c){
quicksort(S, C, 0, S.size()-1);
}private void quicksort (Sequence S, Comparator c,int leftBound,
int rightBound) {// left and rightmost ranks of sorting range
if (S.size() < 2) return; //a sequence with 0 or 1 elements
// is already sorted
if (leftBound >= rightBound) return; //terminate recursion
// pick the pivot as the current last element in range
Object pivot = S.atRank(rightBound).element();
// indices used to scan the sorting range
int leftIndex = leftBound; // will scan rightward
int rightIndex = rightBound - 1; //will scan leftward

19
In Place Quick Sort code (contd.)
// outer loop
while (leftIndex <= rightIndex) {
//scan rightward until an element larger than
//the pivot is found or the indices cross
while ((leftIndex <= rightIndex) &&(c.isLessThanOrEqualTo
(S.atRank(leftIndex).element(),pivot))
leftIndex++;
//scan leftward until an element smaller than
//the pivot is found or the indices cross
while (rightIndex >= leftIndex) &&(c.isGreaterThanOrEqualTo
(S.atRank(rightIndex).element(),pivot))
rightIndex--;
//if an element larger than the pivot and an
//element smaller than the pivot have been
//found, swap them
if (leftIndex < rightIndex)
S.swap(S.atRank(leftIndex),S.atRank(rightIndex));
} // the outer loop continues until 20
// the indices cross. End of outer loop.
In Place Quick Sort code (contd.)
//put the pivot in its place by swapping it
//with the element at leftIndex
S.swap(S.atRank(leftIndex),S.atRank(rightBound));

// the pivot is now at leftIndex, so recur

21
 Analysis of Running Time
• Consider a quick-sort tree T:
– Let si(n) denote the sum of the input sizes of the nodes at depth i in T.
• We know that s0(n) = n since the root of T is associated with the entire
input set.
• Also, s1(n) = n-1 since the pivot is not propagated.
• Thus: either s2(n) = n-3, or n - 2 (if one of the nodes has a zero input
size).
• The worst case running time of a quick-sort is then:
Thus quick-
sort runs in
time O(n2) in
the worst
case

22
 Analysis of Running Time
(contd.)
• Now to look at the best case running time:
• We can see that quicksort behaves optimally if, whenever a sequence
S is divided into subsequences L and G, they are of equal size.
• More precisely:
s0(n) = n
s1(n) = n - 1
s2(n) = n - (1 + 2) = n - 3
s3(n) = n - (1 + 2 + 22) = n - 7
…
si(n) = n - (1 + 2 + 22 + ... + 2i-1) = n - 2i - 1
...
• This implies that T has height O(log n)
• Best Case Time Complexity: O(nlog n)
23
 Randomized Quick-Sort
• Select the pivot as a random element of the sequence.
• The expected running time of randomized quick-sort on a sequence
of size n is O(n log n).
• The time spent at a level of the quick-sort tree is O(n)
• We show that the expected height of the quick-sort tree is O(log n)
• good vs. bad pivots

• The probability of a good pivot is 1/2, thus we expect k/2 good pivots
out of k pivots
• After a good pivot the size of each child sequence is at most 3/4 the
size of the parent sequence
• After h pivots, we expect (3/4)h/2 n elements 24
• The expected height h of the quick-sort tree is at most: 2 log4/3n