308-203a introduction to computing ii lecture 8: sorting 2 fall session 2000

308-203AIntroduction to Computing II

Lecture 8: Sorting 2

Fall Session 2000

So far….

1. Bubblesort - intuitive implementation

(n2) suboptimal

2. MergeSort - Divide-and-Conquer

O(n log n) worst-case optimal

The Problem with MergeSort

We do a lot of copying when we MERGE…

8, 34, 51, 78, 82 2, 17, 64, 91, 123

2, 8, 17, 34, 51, 64, 78, 82, 91, 123

N/2 N/2

New Array: size = N

In Java, for example...

int [] merge(int [] a, int [] b){ int [] c = new int [a.length + b.length];

// merge a and b into c ….

return c;}

The Problem with MergeSort

• To merge we need O(n) extra space

• Copying bigger “hidden constants”

• “Sorting-in-place” would be preferable (if we can do it in optimal n log n)

• Divide-and-Conquer was good, can we do the same thing with an operation other than merge??

Quicksort

64, 8, 78, 34, 82, 51, 17, 2, 91, 123

2. Recursion

2. Partition

1. Pick pivot

2, 8, 17, 34, 51, 64, 78, 82, 91, 123

8, 34, 51, 17, 2 , 64, 78, 82, 91, 123

Quicksort

Quicksort(int [] A, int start, int end){ int pivot = A[0];

int midpoint = Partition(pivot, A);

Quicksort(A, start, midpoint); Quicksort(A, midpoint+1, end);}

Running Time

• Depends significantly on choice of pivot

• Worst-case = O(n2)

• Best-case = O( n log n)

Proofs on separate handout

The Worst-Case is WORSE!

• Worst-case is O(n2) as bad as Bubblesort

• A clever trick:Fooling-the-Adversary

1. pick a random pivot2. You hit a bad case only when very unlucky

• Average-case = O( n log n)

Proof beyond the scope of this course

Randomized Quicksort

Quicksort(int [] A, int start, int end){ int pivot = A[ randomInt(start, end) ];

int midpoint = partition(pivot, A);

Quicksort(A, start, midpoint); Quicksort(A, midpoint+1, end);}

Any questions?