(les03)-quicksort(2)

7/25/2019 (les03)-quicksort(2)

1/28

Algoritmen & Datastructuren2014 2015

Quicksort

Philip Dutr

Dept. of Computer Science, K.U.Leuven


2/28

Overview Lecture

Copyright Ph.Dutr, Spring 20152

Quicksort Quicksort partitioning

Variant 1

Variant 2

Variant 3

Running Times

Performance Analysis Worst

Best

Average

Optimizations

Summary


3/28

Sorting algorithms so far


Insertion sort: ~n2

/4 comparisons average case In-place sorting

Selection sort: ~n2/2 comparisons

In-place sorting

Merge sort: ~n.log2n comparisons

Not in-place (additional memory needed)

http://www.youtube.com/watch?v=k4RRi_ntQc8&feature=related
http://www.youtube.com/watch?v=k4RRi_ntQc8&feature=relatedhttp://www.youtube.com/watch?v=k4RRi_ntQc8&feature=related


4/28

How fast can sorting algorithms go?


Comparison sorts Sort by comparing two elements

Any comparison sort needs at least ~n. log2n comparisons

Merge sort is asymptotically optimal!

Non-comparison sorts, in linear (~ n) time:

Counting sort

Radix sort

Bucket sort See next lecture!


5/28

Quicksort (section 2.3)


Most widely used sorting algorithm (e.g. Java) In-place

No additional memory needed

~1.39.n.log2n on average

Mergesort:

Recurse first (trivial), then merge (do real work) Quicksort:

Partition first (do real work), then recurse (trivial)


6/28

Quicksort


Partitioning of elements: Choose pivot element, e.g. a[j]

Elements a[lo] a[j-1] a[j]

Elements a[j+1] a[hi] a[j]


7/28

Quicksort


public class Quick

{ // Quicksort.

public static void sort(Comparable[] a) {

StdRandom.shuffle(a);

sort(a, 0, a.length - 1);

}

private static void sort(Comparable[] a, intlo, inthi) {

if(hi


8/28

Quicksort



9/28

Quicksort


Charles Hoare (1934)

Quicksort: 1960

ACM Turing Award 1980

1972 Edsger W. Dijkstra

1974 Donald E. Knuth

1988 Ivan Sutherland

2003 Alan Kay


10/28

Quicksort


http://www.youtube.com/watch?v=2HjspVV0jK4
http://www.youtube.com/watch?v=2HjspVV0jK4http://www.youtube.com/watch?v=2HjspVV0jK4


11/28

Quicksort: partitioning, variant 1


Choose pivot element (e.g. first element)

Create 2 arrays: l ef t [ ] and r i ght [ ]

Loop over all elements

If element < pivot, put into l ef t [ ]

If element > pivot, put into r i ght [ ]

(if element == pivot, left or right)

Concatenate l ef t [ ] + pi vot + r i ght [ ]

n-1 number of comparisons


12/28



private static intpartition(Comparable[] a, intlo, inthi)

{ // Partition into a[lo..i-1], a[i], a[i+1..hi].

inti = lo, j = hi+1; // left and right scan indices

Comparable v = a[lo]; // partitioning value

while(true)

{ // Scan right - left, check for scan complete, and exchange

while(less(a[++i], v)) if(i == hi)break;

while(less(v, a[--j])) if(j == lo)break;if(i >= j)break;

exch(a, i, j);

}

exch(a, lo, j); // Put v = a[j] into position

returnj; // with a[lo..j-1]


13/28




14/28

Quicksort: partitioning, variant 3 (Lomuto)



15/28



16/28



17/28

Quicksort: partitioning, variant 3 (Lomuto)


private static intpartition(Comparable[] a, intlo, inthi)

{ // Partition into a[lo..i], a[i+1], a[i+1..hi].

inti = lo-1; // scan index

Comparable v = a[hi]; // partitioning value

for (int j = lo; j


18/28

Running times


Home PC executes 108compares/second.

Supercomputer executes 1012compares/second

Lesson 1: Good algorithms are a better investment thansupercomputers.

Lesson 2: Great algorithms are better than good ones.


19/28

Performance of quicksort


Worst case 0 elements in one subarray and

n 1 elements in the other

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

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

worst-case running time occurs if array is already sorted

insertion sort runs in ~n time in this case


20/28

Worst case



21/28

Performance of quicksort


Best Case Split is balanced

T(n) = 2T(n/2) + partitioning(n)

= ~n . log2n

Suppose split is at 9/10

T(n) = T(9n/10) +T(n/10)+ partitioning(n)

= ~c . n . log2n

Suppose split is at 99/100, 999/1000,

T(n) =~c . n . log2n


22/28

Best case



23/28



24/28

Performance of quicksort:

Intuition for the average case


Any permutation of elements can form the initial array Some splits will be good, others will be bad


25/28

Performance: average case


(mathematical derivation on blackboard)


26/28

Optimizations


Cuttoff to insertion sort Practice: ~ 10 elements

Median of 3 values for pivot

Better probability of splitting in half

Many similar values 3-way partitioning (less, equal, greater)


27/28

Optimizations



28/28

Summary of performance


Worst case

Number of compares is quadratic

But youll win the lottery first!

Average case

Number of compares is ~ 1.39 n log2n

39% more compares than mergesort But faster than mergesort in practice because of less data

movement.

Random shuffle

Probabilistic guarantee against worst case

Basis for math model that can be validated with experiments.

Many textbook implementations go quadratic if array

Is sorted or reverse sorted

Has many duplicates (even if randomized!)

(les03)-quicksort(2)

Documents