Quicksort. Repeat the process recursively for the left- and rightsub-blocks.

Transcription

1 Quicksort As the name implies, this is the fastest known sorting algorithm in practice. It is excellent for average input but bad for the worst-case input. (you will see later). Basic idea: (another divide-and-conquer algorithm) Partition the sequence into 3 sub-blocks Pick an element, say M (the pivot) Re-arrange the elements into 3 sub-blocks, those less than M (the left-block) those greater than M (the right-block) M (the only element in the middle-block) Repeat the process recursively for the left- and rightsub-blocks. Quick Sort COMP171/S2002/L1 1

2 Note: Quicksort (cont d) The main idea is to find the right position for the pivot element M. After each pass, the pivot element, M, should be in place. Eventually, the elements are sorted since each pass puts at least one element into its final position. Issues: How to choose the pivot M? How to partition the block into sub-blocks? Quick Sort COMP171/S2002/L1 2

3 Quicksort (cont d) Variants of Quicksort algorithms are defined by solutions to the issues. Choosing the pivot M: First element Last element Median-of-three elements Random element Partitioning strategy: Bi-directional scan Uni-directional scan Quick Sort COMP171/S2002/L1 3

4 Quicksort: Algorithm I Algorithm I: (M is the first element in the block, Scanning is bi-directional) Scan from the left until we find an element greater than M Scan from the right until we find an element less than M Swap these two elements (why?) Continue until the two indices cross over Swap M with the? element Quick Sort COMP171/S2002/L1 4

5 Quicksort: Algorithm I Code Algorithm I: Pivot element is in the correct position Repeat on the two subsequences int partition(int left, int right); void quicksort(int left, int right) { int k ; if (right > left ) { k = partition(left, right ); quicksort (left, k-1); quicksort (k+1, right); } } Quick Sort COMP171/S2002/L1 5

6 Quicksort: Algorithm I Code (Cont d) Algorithm I:(A[left] is the pivot element) int partition(int left, int right); { M = A[left]; i = left; j = right + 1; for(;;) //infinite for-loop, break to exit { while (A[++i] < M) if (i >= right) break; while (A[--j] > M) if (j <= left) break; if (i >= j ) break; else swap(a[i], A[j]); } if (j == left) return j ; else if (j == (right + 1)) j = j - 1; else swap(a[left], A[j]); return j; } Quick Sort COMP171/S2002/L1 6

7 Quicksort: Numerical Example Input: (n=9) M: 65 #com #swap Pass 1: (i) i j (ii) i j (iii) i j (iv) i j (v) j i Quick Sort COMP171/S2002/L1 7

8 Quicksort: Numerical Example Input: (n=9) Result of Pass 1: 3 sub-blocks: Pass 2a (left sub-block): (M = 60) i j j i Pass 2b (right sub-block): (M = 85) i j j i Quick Sort COMP171/S2002/L1 8

9 Quicksort: Numerical Example Input: (n=9) Result of Pass 2: 5 sub-blocks (3 single element blocks) Pass 3a (left sub-block): (M = 55) i j j i Pass 3b (right sub-block): (M = 70) i j j i Quick Sort COMP171/S2002/L1 9

10 Quicksort: Numerical Example Input: (n=9) Result of Pass 3: Pass 4a (left sub-block): (M = 50) Pass 4b (right sub-block): (M = 80) Result of Pass 4: (sorted) Quick Sort COMP171/S2002/L1 10

11 Quicksort: Analysis Partitioning Step: Time Complexity is O(n). Recall that quicksort involves partitioning; 2 recursive calls. Thus, giving the basic quicksort relation: T(n) = c n + T(i) + T(n-i-1) where i is the size of the first sub-block after partitioning. We shall take T(0) = T(1) = 1 as the initial conditions. To find the solution for this relation, we ll consider three cases: The Worst-case (?) The Best-case (?) The Average-case (?) All depends on the value of the pivot!! Quick Sort COMP171/S2002/L1 11

12 Quicksort: Analysis Worst-Case: (p. 277 of Text) When the pivot is the smallest element ALL the time, i.e.after each pass, i.e. partitioning, on a block of size n, the result yields one empty sub-block, one element in the correct place and one sub-block of size (n-1) takes O(n) data comparisons Recurrence Equation: for i = 0 T(1) = 1 T(n) = T(0) + T(n-1) + c n Solution is O(n 2 ) Worse than Mergesort!!! Data is sorted already. Quick Sort COMP171/S2002/L1 12

13 Quicksort:Analysis Best case: (p.277 of Text) The pivot is in the middle, i.e. after each partitioning, on a block of size n, the result yields two sub-blocks of approximately equal size and the pivot element in the middle position takes O(n) data comparisons. Recurrence Equation becomes T(1) = 1 T(n) = 2T(n/2) + c(n) Solution: O(n logn) Comparable to Mergesort!! Quick Sort COMP171/S2002/L1 13

14 Quicksort:Analysis Average case: (p. 278 of Text) Assume that each block of size i is equally likely and has the probability of 1/n. The average value of T(i), and T(n-i-1) is n 1 (1 / n ) T ( j ) j = 0 Recurrence Equation becomes T (1) = 1 T ( n) = (2 / n) n 1 j = 0 T ( j) + cn Solution: O(n logn) Quick Sort COMP171/S2002/L1 14

15 Sorting Summary Sorting Method Worst-case time Averagecase time Space overhead Bubble Sort O(n 2 ) O(n 2 ) Θ(1) Insertion Sort O(n 2 ) O(n 2 ) Θ(1) Mergesort O(n log n) O(n log n) Θ(n) Quick Sort O(n 2 ) O(n log n) Θ(1) Quick Sort COMP171/S2002/L1 15