Download presentation

Presentation is loading. Please wait.

Published byJackson Ayers Modified over 2 years ago

1
1 Chapter 9 continued: Quicksort Similar to mergesort: divide and conquer, recursive algorithm Average running time is O(nlogn) O(n 2 ) worst case performance, (can be made exponentially unlikely) Simple to understand and prove correct –But for many years hard to implement In practice, faster than mergesort Lecture 19 ADS2 Lecture 19

2
2 Basic algorithm to sort array S: If number of elements in S is 0 or 1, then return. Pick any element v in S. This is called the pivot Partition S-{v} (the remaining elements in S) into sets S 1 = set of elements in S-{v} v and S 2 = set of elements in S-{v} v Return{quicksort (S 1 ) followed by v followed by quicksort(S 2 )} Note that: Choice of pivot is crucial When we reassemble, no need to merge ADS2 Lecture 19

3
Example: illustration of steps select pivot 65 partition quicksort small quicksort large ADS2 Lecture 19

4
4 Example for you Use quicksort to sort: Include all stages How did you choose your pivot in each case? – describe the strategy used –(e.g. let first element be the pivot) ADS2 Lecture 19

5
5 Picking the pivot – some inadvisable options Use first element –Acceptable if input is random –Very poor if input is presorted or in reverse order Virtually all the elements go into S 1 or into S 2 This happens consistently throughout recursive calls If input already presorted, will take quadratic time to do nothing at all! Choose larger of first two elements –Same problems as above Pick pivot randomly –Theoretically a good idea, unlikely that random number would consistently provide a bad partition (unless random number generator flawed – possible!) –Random number generation is expensive ADS2 Lecture 19

6
6 Median of three partitioning Median of n numbers is the ([n/2] +1)th element (index [n/2]) when placed in order E.g. –median of -1,0,1,4,5,11 is the 4 th, i.e. 4 –median of -2, 0, 8, 33, 34, 35, 57 is the 4 th, i.e. 33 Median would be the ideal pivot –Would be balanced (approx half elements would go into S 1 and half into S 2 ) –But hard to calculate and slow (need to sort first!) Compromise : median of left, centre and right element (without ordering whole array) –Centre position is (left+right)/2 –Take the middle of the three. –For -2, 0, 8, 33, 24, 35, -7 take median of -2, 33 and -7 (i.e. -2) –For -2,0, 8,33,24,35,26,-7 take median of -2,33 and -7 (i.e. -2 again) ADS2 Lecture 19

7
7 Partitioning strategy One of several. Known to give good results First step, move pivot to far right by swapping with right element Second step, set i to left element, and j to right identify pivot swap pivot and last element i j We will assume all elements are distinct -And consider the case when they are not, later ADS2 Lecture 19

8
8 Partitioning strategy contd. Move all small elements to left part of array, and all large elements to right While i is to the left of j, move i right, skipping over elements smaller than pivot Move j left, skipping over elements larger than pivot When i and j have stopped, i is pointing to large element, and j to small –If i is to left of j, swap those elements Finally, swap element pointed to by i with the pivot. ADS2 Lecture 19

9
9 Partitioning example i j i stays the same as 8 is already> pivot j skips along to element 2 Swap those elements and repeat the process i j after first swap: ij before second swap: i j after second swap: before first swap i j before third swap: STOP: i and j have crossed After swap with pivot: i ADS2 Lecture 19

10
10 Partitioning example continued When finished, evey element in position p i is large Would then apply quicksort to the lists (arrays) 2,1,4,5,0 3 and 8,7,9 Example for you: complete the next stage of the process, i.e. partition the list 2,1,4,5,0,3 ADS2 Lecture 19

11
11 When some elements are identical Most importantly, when an element that is not pivot has same value as pivot should we stop or skip ? -Should do the same for i and j so that partitioning is not biased - In each case, suppose that all elements are identical. Stopping: many swaps between identical elements but i and j cross in middle, so when pivot replaced 2 nearly equal partitions are created (so, like mergesort, O(nlogn)) Skipping: no swaps between identical elements but i and j do not cross in middle, so pivot will be (re)placed at last, or second last position. Unequal parts. If all vals identical, O(n 2 ) see board So we choose to stop ADS2 Lecture 19

12
12 Small arrays : using a cutoff For small arrays, quicksort not as fast as insertion sort As quicksort is recursive, these cases will occur frequently Solution: use quicksort until arrays are small, then use insertion sort on whole array Works very well as insertion sort v efficient for nearly sorted arrays Can save about 15% in running time. Good cutoff range is n=10, but any cutoff between 5 and 20 likely to produce similar results Also avoids problems like finding median of three when only two elements left ADS2 Lecture 19

13
13 Quicksort in practice see board for discussion MedianOfThree algorithm Algorithm MedianOfThree(A,x,y): Input: An array A and integers x,y 0, such that A has indices x.. y Output: value of pivot Note : A will have pivot at position y c (x+y)/2 if A[x]>A[c] then swap(A,x,c) if A[x]>A[y] then swap(A,x,y) if A[c]>A[y] then swap(A,c,y) pivot c swap(A,c,y) return pivot ADS2 Lecture 19

14
14 Quicksort in practice contd. Algorithm QuickSort(A,x,y,cutoff): Input: An array A and integers x,y 0, such that A has indices x.. y, and integer cutoff Output : A (almost) sorted if (y-x)>cutoff then pivot=MedianOfThree(A,x,y) i x j y-1 while i<=j do while A[i]

15
15 QuickSort – Putting it all together This is an exercise for you (part of Lab 5) Need to include following methods: –swap –medianOfThree –insertionSort –qSort –You will be sorting an array of country names. –quickSort will need to be generic –Will also need to convert mergeSort to be generic, and compare timings for quickSort, mergeSort, insertionSort, and bubbleSort. ADS2 Lecture 19

16
16 Analysis of Quicksort As for mergesort, T(0)=T(1)=1 Running time for array of size n is equal to running time of two recursive calls plus the linear time spent in the partition (pivot selection takes only constant time) Basic quicksort relation is T(n) = T(i) +T(n-i-1) +cn where i=|S 1 | = number of elements in S 1 Worst case: O(n 2 ) Best-Case: O(n log n) Average-case: O(n log n) will prove the first two of these on the board ADS2 Lecture 19

17
17 Finally: Comparison of quicksort and mergesort 1.Both routines recursively solve two subproblems and require linear additional work, but 2.Unlike mergesort, in quicksort subproblems not guaranteed to be of equal size 3.However, quicksort is faster because partitioning step can be performed in place, very efficiently. More than makes up for (2). ADS2 Lecture 19

18
18 Some examples for you (See extra quicksort examples contained in Lectures folder) Sort 3,1,4,1,5,9,2,6,5,3,5 using quicksort with median-of-three partitioning and a cutoff of 3 Perform the first partitioning stage on 11,10,9,8,7,6,5,4,3,2,1 What do you notice? Construct a permutation of 20 elements that is as bad as possible for quicksort, using median-of-three partitioning and a cutoff of 3 ADS2 Lecture 19

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google