COSC242 Lecture 8 More Quicksort

Transcription

1 COSC242 Lecture 8 More Quicksort If the pivot divides the array into two pieces of roughly the same size each time, then Quicksort behaves like Mergesort with log n splits of the array. More precisely, T(n) = f(n) + T(n/2) + T(n/2) where f(n) is the time taken by Partition. Since Partition compares every key in A[0.. (n - 1)] to the pivot x, the running time for partition is linear, with time complexity f(n) = n. So Quicksort has a time complexity function T given by T(1) = 1 T(n) = 2T(n/2) + n which, like mergesort, has the solution T(n) = n log n + n and so is Θ(n log n). But this is if the pivot divides the array in a balanced way. COSC242 Lecture 8 / 4 August 2016 / Slide 1

2 Worst Case If Partition picks out the smallest or biggest key as the pivot every time, the subarrays always have 1 key in one subarray and all the other keys in the other. Then T(n) = T(n 1) + n which we can solve by iteration to get T(n) = n = n(n + 1)/2 = 1 2 n n. So in the worst case, when the pivot always divides the array in a very unbalanced way, Quicksort is Θ(n 2 ). Reminder: n n 2 n log n COSC242 Lecture 8 / 4 August 2016 / Slide 2

3 Proportional Splits How robust is the average case for quicksort? We know that having extremely unbalanced splits of 1 to n 1 will give us n 2 comparisons. But can we survive a bit of imbalance, or do we really need exactly n/2 items on each side? Consider a partitioning algorithm which consistently used a pivot that gave us a 90% split (sounds pretty bad). The recurrence would then be: T(n) = T(9n/10) + T(n/10) + n which is hard to get a solution for by iterating! Use a recursion tree instead: log 10 n n 9n/10 n/10 log n 10/9 81n/100 9n/ n/100 n/ n/ n/ COSC242 Lecture 8 / 4 August 2016 / Slide 3

4 Proportional Splits Since each layer of the tree does at most n things and there are at most log 10/9 n layers, total time is still O(n log n). This is true for any split that keeps the same proportion, even a 99 to 1 split. (But note that a split of n 1 to 1 is not of constant proportion, which is why we got O(n 2 ) in that case.) What about alternating a perfect split with a bad split? n 1 n 1 (n 1) / 2 (n 1) / 2 n (n 1) / (n 1) / 2 COSC242 Lecture 8 / 4 August 2016 / Slide 4

5 Random choice of pivots We could try to ensure constant proportionality of splits, but that seems much harder than simply making sure the bad splits don t occur too often. If we choose good and bad splits at random, the overall effect is as if they were all good (ignoring constants). So, we could use a random number generator to pick a pivot and swap it with the item at A[0]. Partition itself need not change: Randomised-Partition(A, low, high) 1: i Random(low, high) 2: swap A[0] with A[i] 3: return Partition(A, low, high) Now we can expect the split of the input array to be fairly balanced most of the time. With the randomised partition algorithm in our quicksort, the average case complexity of quicksort is Θ(n log n). COSC242 Lecture 8 / 4 August 2016 / Slide 5

6 Median of Three There is another way to make the chance of the worst case arising very small. We can choose the pivot not randomly but by using the median-of-three strategy. If you have n numbers, their median is the n/2-th largest number. It takes too much time to check which key in an array of length n is the median, but it is easy to find the median of, say, the first key in the array, the last key, and the middle key. Example. Given 6, 1, 4, 9, 8, 3, 5, 2, 7, 0, the leftmost element is 6, the rightmost is 0, and the centre element is 8, so the median-of-3 would be 6, which is not a bad pivot for the given input values. COSC242 Lecture 8 / 4 August 2016 / Slide 6

7 Dropping to insertion sort Every time quicksort s partition algorithm is applied on a subarray of the input, the data items are closer to being sorted, so that by the time the subarrays get small, the data will be nearly sorted. But insertion sort is much better than quicksort on nearly-sorted data. This gives us a way to improve quicksort. Pick a small enough size, and when the quicksort algorithm reaches the point of calling itself on a subarray which is that small, let it return without sorting the subarray. When the top-level call to quicksort returns (i.e. all the subarrays have supposedly been sorted), then take advantage of the fact that insertion sort is quite fast on nearly-sorted data to finish up by running insertion-sort on the whole nearly-sorted array. Weiss claims that this saves about 15% in the running time when compared with sticking to quicksort the whole way through, and recommends a cutoff size of n = 10. COSC242 Lecture 8 / 4 August 2016 / Slide 7

8 Insertion, Merge, and Quicksort Insertion Sort is O(n 2 ), Mergesort is O(n log n), and Quicksort is O(n log n) if we avoid the worst case scenario. Insertion Sort is O(n) on (nearly-)sorted data, Mergesort doesn t care and stays O(n log n), while Quicksort hates sorted data (at least if we use our unmodified Partition algorithm) and becomes O(n 2 ) instead of O(n log n). A sorting algorithm is stable if equal keys are left in the same relative order. For example, suppose we have a list of students sorted into alphabetical order, with two students having the same name, say Smith. If we now use a stable sorting algorithm to sort the list according to GPA, then students with the same GPA will still be in alphabetical order. Insertion sort is stable, Quicksort is not, and our Merge algorithm makes Mergesort unstable. Why? Insertion and Quicksort sort in-place so use minimal space, but Mergesort requires extra space for merging. On the other hand, the Merge routine makes Mergesort the algorithm of choice for sorting large amounts of data stored externally on one or several disks. COSC242 Lecture 8 / 4 August 2016 / Slide 8