Design and Analysis of Algorithms

Transcription

1 Design and Analysis of Algorithms Dr. M. G. Abbas Malik Assistant Professor COMSATS Institute t of Information Technology, Lahore

2 Quick Sort Proposed by C. A. R. Hoare in 1962 Divide-and-Conquer algorithm Sorts in place (like Insertion sort, not like Merge Sort) Very practical (with tuning) 2

3 Quick Sort Sort an n-element array Divide-and-Conquer Algorithm 1. Divide: Partition the array into two sub-arrays around a Pivot x such that elements in sub-array-1 x elements in sub-array-2 x x x 2. Conquer: Recursively sort two sub-arrays. 3. Combine: Trivial. Key: Linear-time partitioning algorithm 3

4 Quick Sort Partitioning Algorithm 4 Partition(A, LeftIndex, RightIndex){ x = A[LeftIndex] i = LeftIndex for j = LeftIndex+1 to RightIndex { if A[j] x then i= i+ 1 exchange A[i] A[j] } exchange A[LeftIndex] A[i] Return i } Left Index Running Time = O(n) for n-elements x x x? Right Index

5 Example of Partitioning i j 5

6 Example of Partitioning i j 6

7 Example of Partitioning i j 7

8 Example of Partitioning i j 8

9 Example of Partitioning i j 9

10 Example of Partitioning i j 10

11 Example of Partitioning i j 11

12 Example of Partitioning i j 12

13 Example of Partitioning i j 13

14 Example of Partitioning i j 14

15 Example of Partitioning i j 15

16 Example of Partitioning i 16

17 Quick Sort Quicksort(A, LeftIndex, RightIndex) { } if LeftIndex < RightIndex then PivotIndex = Partition(A, LeftIndex, RightIndex) Quicksort(A, LeftIndex, PivotIndex-1) Quicksort(A, PivotIndex+1, RightIndex) Initial Call: Quicksort(A, 1, n) 17

18 Analysis of Quick Sort Assume all input elements are distinct. In practice, there are better partitioning algorithms for when duplicate input elements may exist. Let T(n) = Worst-case running time on an array of n elements. 18

19 Worst-case of Quick Sort Input sorted or reversely sorted Partitioning around min or max element. One side of partition always has no elements. (Arithmetic series) 19

20 Worst-case Recursion Tree 20

21 Worst-case Recursion Tree T(n) 21

22 Worst-case Recursion Tree cn T(0) T(n-1) 22

23 Worst-case Recursion Tree cn T(0) c(n-1) T(0) T(n-2) 23

24 Worst-case Recursion Tree cn T(0) c(n-1) T(0) c(n-2) T(0) 24 Θ(1)

25 Worst-case Recursion Tree cn T(0) c(n-1) T(0) c(n-2) T(0) 25 Θ(1)

26 Worst-case Recursion Tree cn h=n Θ(1) ) c(n-1) Θ(1) c(n-2) Θ(1) 26 Θ(1)

27 Best-case Analysis of Quick Sort If we are lucky, Partition splits the input array evenly: same as merge sort What if the split is always? What is the solution to this recursion? 27

28 Analysis of Almost-Best case T(n) 28

29 Analysis of Almost-Best case cn T(n/10) T(9n/10) 29

30 Analysis of Almost-Best case cn cn/10 9cn/10 T(n/100) T(9n/100) T(9n/100) T(81n/100) 30

31 Analysis of Almost-Best case cn cn cn/10 9cn/10 cn cn/100 9cn/100 9cn/100 81cn/100 cn Θ(1) 31 O(n) Leaves Θ(1)

32 Analysis of Almost-Best case cn cn cn/10 9cn/10 cn T(n/100) T(9n/100) T(9n/100) T(81n/100) cn Θ(1) 32 O(n) Leaves Θ(1)

33 Quick Sort in Practice Quick sort is a great general purpose sorting algorithm Quick sort is typically over twice as fast as Merge sort. 33