Quicksort CSE 331 Section 2 James Daly

Review: Merge Sort Basic idea: split the list into two parts, sort both parts, then merge the two lists AB C

Review : Merge Sort There are O(log n) levels Each level requires O(n) work (across all sub- problems) Comparisons Copying Total runtime is O(n log n) Limitation: Not in place (requires O(n) extra memory)

Quicksort Fastest general-purpose comparison-based sorting algorithm Showcases a Divide-and-Conquer approach

Quicksort Approach: Select a pivot Partition into low and high sets (divide) Sort both parts (conquer)

Quicksort Example

Quicksort( A, l, r ) if (l < r) then p ← Partition(A, l, r) Quicksort(A, l, p – 1) Quicksort(A, p + 1, r) Left and right indices

Partition( A, l, r ) pivot ← A[r] i ← l, j ← r - 1 while (i < j) while(A[i] < pivot) i++ while(A[j] > pivot) j—- if (i < j) Swap(A[i], A[j]) Swap(A[i], A[r]) return i

Quicksort( A, l, r ) if (l < r) then p ← Partition(A, l, r) Quicksort(A, l, p – 1) Quicksort(A, p + 1, r) O(n) T(|Low|) T(|High|) T(n) O(1)

Best Case Both halves get half of the items |Low| = |High| = n/2 T(n) = 1 + n + T(n/2) + T(n/2) = 1 + n + 2T(n/2) T(n) = Θ (n log n) (See Merge Sort analysis)

Worst Case All the items are on one side Either |Low| = n – 1 or |High| = n – 1 T(n) = 1 + n + T(n – 1) T(n) = O(n 2 ) n n-1 n-2 n-3 1

Average Case What if we are only kind of bad? Assume up to 90% of items end up on one side Height?

Average Case Height Up to n( 9 / 10 ) k items in biggest part of level k Stop when only 1 item in part n( 9 / 10 ) k = 1 k = log n T(n) = Θ (n log n) [average] 10 / 9

Pivot Choice Our implementation always chooses the last element as the pivot Performs badly on already sorted data Choice of pivot is arbitrary

Median of Three Select three elements First, last, and middle items are common Make the median item be the pivot Guarantees that each part is non-empty Performs well on the sorted case Be careful when you get to small sizes!

Random Pivot Pick one of the elements at random to be the pivot Must be profoundly unlucky to hit the worst case An adversary cannot give you bad input without hacking your random number generator Note that generating random numbers is moderately expensive

Insertion Sort Insertion Sort is better than Quicksort on small inputs Stop recursing when a part has fewer than k elements Leaves the part unsorted! Each element is no more than k spots from the correct spot Insertion sort the whole array at once