Download presentation

Presentation is loading. Please wait.

Published byEbony Jakeway Modified about 1 year ago

1
1 Sorting in Linear Time How can we do better? CountingSort RadixSort BucketSort

2
2 Counting Sort No comparisons between elements But depends on assumptions about the values being sorted Each of the n input elements is an integer in the range 0 to k When k = (n), the sort runs in (n) time The algorithm: Input: A[1..n] where A[ j ] {0, 1, …, k} Output: B[1..n], sorted –Notice: elements are not sorted in place Also: C[1..k] for auxiliary storage

3
3 Counting Sort (cont) Counting-Sort(A, B, k) 1.for i 0 to k 2.C[i] 0 3.for j 1 to Length(A) 4.C[A[j]] C[A[j]] + 1 5.// C[i] now contains the number of elements = i 6.for i 1 to k 7.C[i] C[i] + C[i-1] 8.// C[i] now contains the number of elements i 9.for j Length(A) downto 1 10.B[C[A[j]]] A[j] 11.C[A[j]] C[A[j]] – 1 k+2 k+1 n+1 n k+1 k n+1 n ------------------------------------- --------------------------------------- -------------------------- ----------------------- ------------------------------------- -------------------------- -------------------- --------------------------- -----------------------

4
4

5
5 Analysis of CountingSort: (nlgn) does not apply because CountingSort isn’t a comparison sort CountingSort is stable.

6
6 Radix Sort This sort was originally used to sort computer punch-card decks. It is currently used for multi-key sorts for example: year/month/day Consider each digit of the number as a separate key

7
7 Radix Sort (cont) Idea 1: Sort on most significant digit n, then sort on digit n-1, etc. Problem: For old sorters, sort into 10 bins, but subsequent recursive sorts require all 10 bins Operator must store the other 9 piles Idea 2: Sort on least significant digit, then sort on next least significant digit, etc.

8
8 Radix Sort (cont) Radix-Sort(A, d) for i 1 to d use a stable sort to sort array A on digit d

9
9 Radix Sort (cont) Radix-n: another way of indicating the sort used Implies each digit can differentiate among n different symbols. In the previous case we assumed radix-10. This is why the name Radix Sort is given

10
10 Analysis of RadixSort If each digit is in the range 1 to k (or 0 to k-1), use CountingSort for each pass Each pass over a digit is (n + k) For d digits (d(n + k)) If d is a constant and k = (n) T(n) = (n)

11
11 Proof by induction that RadixSort works Base Case: d = 1 since only one digit, sorting by that digit sorts the list Inductive Step: Assume it holds for d – 1digits Show: that it works for d digits A radix sort of d digits is the same as a radix sort of d-1 digits followed by a sort on digit d By our inductive hypothesis, the sort on d-1 digits works and the digits are in order according to their low-order d- 1 digits

12
12 Proof by induction that RadixSort works (cont) The sort on digit d will order the elements by their d th digit Consider two elements a and b, with d th digits a d and b d respectively If a d < b d, the sort will put a before b, which is correct, since a < b regardless of their low order digits

13
13 Proof by induction that RadixSort works (cont) If a d > b d, the sort will put a after b, which is correct, since a > b regardless of their low order digits if a d = b d, the sort will leave a and b in the same order they were in, because it is stable. But that order is already correct, since the correct order of a and b is determined by the low-order d-1 digits when their d th digits are equal

14
14 Radix Sort Example Show how n integers in the range 1 to n 2 can be sorted in (n) time Subtract 1 from each number So they’re in the range 0 to n 2 -1 We’ll add the one back after they are sorted Use a radix-n sort Each digit requires n symbols, and log n n 2 digits are needed (d=2, k=n). i.e., treat the numbers as 2-digit numbers in radix n Each digit ranges from 0 to n-1

15
15 Radix Sort Example (cont) Sort these 2-digit numbers with radix sort There are 2 calls to counting sort For (2(n + n)) = (n) time The passes to subtract 1 and add 1each take (n) time Hence, total running time of (n)

16
16 Bucket Sort Bucket Sort assumes that the input values are uniformly distributed over the range [0,1), 0 x < 1 Procedure: Divide inputs into n equal-sized subintervals (buckets) over the range [0,1). Sort each bucket and concatenate the buckets. T(n) = (n)

17
17 Bucket Sort (cont)

18
18 Bucket Sort (cont) Bucket-Sort(A) 1.n Length(A)1 2.for i 1 to nn+1 3.insert A[i] into list B[ nA[i] ]n 4.for i 0 to n – 1n+1 5.sort list B[i] with InsertionSortn*T(n) 6.concatenate the lists B[0], B[1], …,B[n-1] n together in order

19
19 Analysis of Bucket Sort All lines except Line 5 take (n) time What is the cost of the calls to InsertionSort? Let n i be the random variable denoting the number of elements in bucket B[i] And we know that InsertionSort runs in (n 2 ) time

20
20 Analysis of Bucket Sort (cont) By equation c.21 EQ 8.2 EQ 8.1

21
21 Analysis of Bucket Sort (cont) To prove the above equation, define indicator random variables X ij = I{A[j] falls into bucket i] –for i = 0, 1, …, n-1 –for j = 1, 2, …, n Thus…

22
22 Analysis of Bucket Sort (cont) EQ 8.3

23
23 Analysis of Bucket Sort (cont) Evaluate the two summations separately Lemma 5.1 E[X A ] = Pr{A}

24
24 Analysis of Bucket Sort (cont) Substitute these into EQ 8.3 Which proves EQ 8.2

25
25 Thus, when input is drawn from a uniform distribution, BucketSort runs in linear time Analysis of Bucket Sort (cont) Use the expected value in EQ 8.1

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google