Data Structures and Algorithms

Transcription

1 Data Structures and Algorithms Spring

2 Outline 1 Sorting Algorithms (contd.)

3 Outline Sorting Algorithms (contd.) 1 Sorting Algorithms (contd.)

4 Analysis of Quicksort Time to sort array of length 0, 1 is 1: T (0) = T (1) = 1 T (n) = T (i) + T (n i 1) + cn where i = S 1 and c is an appropriate constant Three cases to consider: worst case, best case and average case Best-case analysis Pivot will split S exactly in half T (n) = 2T (n/2) + cn = cn log n + n = O(n log n)

5 Analysis of Worst-case analysis Pivot is smallest every time: i = 0 T (n) = T (n 1) + cn T (n 1) = T (n 2) + c(n 1). T (2) = T (1) + 2c n T (n) = T (1) + c i = O(n 2 ) i=2

6 Analysis of Average-case analysis Let T (n) be average time to sort n values: Assume that every element has equal likelihood of being the pivot element This is only valid if every sub-array is random If the pivot element is jth largest (1 j n), which occurs with prob. 1/n, and cn is work done partitioning the set, then T (n) = cn + 1 n (T (j 1) + T (n j)) n j=1 = cn + 1 n 1 (T (j) + T (n j 1)) n j=0

7 Analysis of Therefore, and T (n) = 2 n 1 T (j) + cn n j=0 n 1 nt (n) = 2 T (j) + cn 2 j=0 n 2 (n 1)T (n 1) = 2 T (j) + c(n 1) 2 j=0 By subtracting the previous two equations, we get nt (n) (n 1)T (n 1) = 2T (n 1) + 2cn c nt (n) = (n + 1)T (n 1) + 2cn c

8 Analysis of By dropping c term to simplify the expression and by dividing by n(n + 1) we have a sum that can telescope T (n) n + 1 T (n 1) n T (2) 3 T (n 1) = n T (n 2) = n 1. = T (1) 2 + 2c 3 + 2c n c n

9 Analysis of Thus, by adding all terms n+1 T (n) n + 1 = T (1) + 2c i=3 2c log e (n + 1) 2c log e log n 1 i And so, T (n) = O(n log n) Thus quicksort() runs in O(n log n) average time.

10 Outline Sorting Algorithms (contd.) 1 Sorting Algorithms (contd.)

11 : Finding the k th Largest Element Using priority queues we can find the kth largest element in time O(n + k log n) So finding the median element will take us (worst-case) O(n + n 2 log n) = O(n log n) In each call to quicksort() the set is partitioned about pivot element, whose final resting place we know If we re looking for the k th largest (smallest) element, since we know their sizes, and from the position of the pivot, we know which set, S 1 or S 2, we should be looking for it in So we only need to make one recursive call at each step From our analysis of General Solutions to Divide and Conquer when 1 = a < c = 2 the best-case running time for the algorithm must be O(n) We can show also that average-case running-time is O(n)

12 Outline Sorting Algorithms (contd.) 1 Sorting Algorithms (contd.)

13 Best Possible Performance Is O(n log n)-time as good as we can do from a sorting algorithm? Yes, provided we are limited to two-way comparisons of elements in unit time In these cases we show that in the worst case: any algorithm that uses only two-way comparisons requires log n! comparisons in the worst case and log n! comparisons in the average case

14 The Tree of All Orderings Idea: Given n items, {a, b, c,..., }, correct ordering is just one of n! possible orderings of items Through a 20 Questions -type of procedure the algorithm has to try and determine which one of the possible n! orderings has been given as the input We can think of all the possible orderings as being the leaves of a tree The branches of the internal nodes are decision points i.e., if a < b branch left, o/w branch right We have to ask enough questions to get us to a unique / leaf ordering: how deep will be the tree?

15 The Tree of All Orderings (contd.) a < c All possible inputs a < b < c a < c < b c < a < b a < b a > c a < b < c a < c < b b < a < c b < c < a c < a < b c < b < a a > b b < a < c b < c < a c < b < a b < c a < b < c a < b < c a < c < b c > b a < c < b c < a < b

16 The Tree of All Orderings (contd.) Easy to show by induction that a binary tree of depth d has at most 2 d leaves Therefore, a binary tree with L leaves will have depth at least log L Now, since any decision tree on n elements must have n! leaves a unique leaf for each possible ordering any sorting algorithm using only 2-way comparisons between elements needs at least log L comparisons in worst case log n! = log(n n 1 1) log n + log(n 1) + + log n 2 n 2 log n 2, and, since log a b = log a log b, n 2 log n n 2 = Ω(n log n)

17 Outline Sorting Algorithms (contd.) 1 Sorting Algorithms (contd.)

18 Bucket Sort Revisited We saw radix sort could sort data into buckets in time O(p(n + b)), p is number of passes and p = f (b) This is linear in n However, when we decide what bucket to put an element in to, we are doing a b-way comparison, hence this sort does not fit our previous model

19 More Sorting Algorithms Use these algorithms at your peril And bringing sorting algorithms to the masses: Quick sort Merge sort Insert sort