QUICK SORT

1
University Institute of Engineering (UIE)
 QUICK SORT

• Developed by Hoare in 1960

• Based on the Divide and Conquer Approach
• Fastest known sorting algorithm in practice
• Average case: O(N log N)
• Best Case: O(N log N)
• Worst case: O(N2)

2
University Institute of Engineering (UIE)
 Divide and Conquer
Approach
• Quick-sort is a sorting algorithm
based on the divide-and-
conquer paradigm: x
– Divide: pick a random element
x (called pivot) and partition S
into
• L elements less than x x
• E elements equal x L E G
• G elements greater than x
– Recur: sort L and G
– Conquer: join L, E and G
– Base case : List of size 0 or 1. x

University Institute of Engineering (UIE) 3

 Algorithm for Quick Sort
• Partition(A,p,r)
p:indicates initial value
r indicates final value • 1. x=A[r]
q: indicates the position of • 2. i=p-1
the pivot value
A: array • 3. For j=p to r-1
• Quicksort (A,p,r) • 4. do if A[j]<=x
• If (p<r) • 5. then i=i+1
• then q =partition • 6. exchange A[i]<-> A[j]
(A,p,r) • 7. exchange A[i+1]<-> A[r]
• Quicksort(A,p,q-1) • 8. return i+1
• Quicksort(A,q+1,r)
Note : To sort an entire array A, the initial call is QUICKSORT(A, 1,
length[A])

University Institute of Engineering (UIE) 4

 Partitioning

• Partitioning : The key to the algorithm is the PARTITION

procedure, which rearranges the subarray A[p…r] in
place.
– Key step of quicksort algorithm
– Goal: given the picked pivot, partition the remaining
elements into two smaller sets
– Many ways to implement
– Even the slightest deviations may cause surprisingly bad
results.
• We will learn an easy and efficient partitioning strategy
here.
• How to pick a pivot will be discussed later
5
University Institute of Engineering (UIE)
 Small arrays
• For very small arrays, quicksort does not perform as well
as insertion sort
– how small depends on many factors, such as the time
spent making a recursive call, the compiler, etc
• Do not use quicksort recursively for small arrays
– Instead, use a sorting algorithm that is efficient for small
arrays, such as insertion sort

6
University Institute of Engineering (UIE)
 Analysis

• Assumptions:
– A pivot at the last element of the array.
• Running time
– pivot selection: constant time O(1)
– partitioning: linear time Θ(n) where n=r-p+1
– running time of the two recursive calls
• T(N)=T(i)+T(N-i)+cN where c is a constant
– i: number of elements in L
– Rest n-i present in G or vice versa

7
University Institute of Engineering (UIE)
 Worst-case Running Time
• The worst case for quick-sort occurs when the pivot is
the unique minimum or maximum element
• One of L and G has size n 1 and the other has size 0
• The running time is proportional to the sum
n  (n  1) …  2 
• Thus, the worst-case running time of quick-sort is O(n2)

depth time
0 n

1 n1
…
… …

n1 1 8
University Institute of Engineering (UIE)
 Picking the Pivot
• Random number
• Median of the array
• Median of the three

9
University Institute of Engineering (UIE)
 Pivot : Any Random

• Use the first or last element as pivot

– if the input is random, ok
– if the input is presorted (or in reverse order)
• all the elements go into L or G.
• this happens consistently throughout the recursive calls
• Results in O(n2) behavior
• Choose the pivot randomly
– generally safe
– random number generation can be expensive

10
University Institute of Engineering (UIE)
 Pivot : The Median of Array

• Use the median of the array

– Partitioning always cuts the array into roughly half
– An optimal quick sort (O(N log N))
– However, hard to find the exact median
• e.g., sort an array to pick the value in the middle

11
University Institute of Engineering (UIE)
 Pivot: median of three
• \We will use median of three
– Compare just three elements: the leftmost, rightmost and center
– Swap these elements if necessary so that
• A[left] = Smallest
• A[right] = Largest
• A[center] = Median of three
– Pick A[center] as the pivot

12
University Institute of Engineering (UIE)
 Pivot: median of three

A[left] = 2, A[center] = 13,

2 5 6 4 13 3 12 19 6
A[right] = 6

2 5 6 4 6 3 12 19 13 Swap A[center] and A[right]

2 5 6 4 6 3 12 19 13 Choose A[center] as pivot

pivot

3 12

13
University Institute of Engineering (UIE)
 Expected Running Time
• Consider a recursive call of quick-sort on a sequence of size s
– Good call: the sizes of L and G are each less than 3s4
– Bad call: one of L and G has size greater than 3s4

7 2 9 43 7 6 19 7 2 9 43 7 6 1
• A call is good with probability 12
– 1/2 of the possible pivots cause good calls:
2 4 3 1 7 9 7 1  1 1 7294376

Good call Bad call

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Bad pivots Good pivots Bad pivots

University Institute of Engineering (UIE) 14

 Summary of Sorting Algorithms

Algorithm Time Notes

 in-place
selection-sort O(n )2
 slow (good for small inputs)
 in-place
insertion-sort O(n )2
 slow (good for small inputs)

O(n log n)  in-place, randomized

quick-sort
expected  fastest (good for large inputs)
 in-place
heap-sort O(n log n)  fast (good for very large inputs)
 sequential data access
merge-sort O(n log n)  fast (good for huge inputs)

University Institute of Engineering (UIE) 15

 Problem
• Suppose the the partitioning algorithm
Produces a 9 to 1 proportional spilt. The recurrence
relation obtained is:

• T(n)<= T(9n/10) + T(n/10) + cn

• Prove that the Complexity is O(nlgn )

16
University Institute of Engineering (UIE)
 References
• Introduction to Algorithms
Thomas H. Cormen,
Charles E. Leiserson
Ronald L. Rivest
• Data Structures Using C and C++
Andrew S. Tanenbaum
• www.utdallas.edu/~daescu/QuickSort.ppt
• http://en.wikipedia.org/wiki/Quicksort

17
University Institute of Engineering (UIE)
•Thanks

18
University Institute of Engineering (UIE)