CSE465, Spring 2009 March 16 1

Size: px

Start display at page:

Download "CSE465, Spring 2009 March 16 1"

Nicholas Boone
6 years ago
Views:

1 CSE465, Spring 2009 March 16 1 Bucket sort Bucket sort has two meanings. One is similar to that of Counting sort that is described in the book. We assume that every entry to be sorted is in the set {0, 1,..., m 1}. We sort array fragment < A,0, n >using array of buckets B[m]. Bucket_sort(A,n,B,m) { // distribution for (i = 0; i < m; i++) place A[i] in bucket B[A[i]]; // collection for (i = j = 0; j < m; j++ ) { while (B[j] is empty) x = removed from B[j], A[i++] = x; } }

2 CSE465, Spring 2009 March 16 2 Example B[0] B[1] B[2] B[3] B[4] B[5]

3 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

4 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

5 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

6 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

7 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

8 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

9 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

10 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

11 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

12 CSE465, Spring 2009 March 16 3 Distribution: B[0] B[1] B[2] B[3] B[4] B[5]

13 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

14 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

15 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

16 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

17 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

18 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

19 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

20 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

21 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

22 CSE465, Spring 2009 March 16 4 Collection:: B[0] B[1] B[2] B[3] B[4] B[5]

23 CSE465, Spring 2009 March 16 5 Counting sort We can use fragments of another array as buckets. If we place them appropriately, we do not need Collection stage instead, we need to perform Census stage to calculate the placement of the buckets. Counting_sort(A,B,n) { int C[m+1]; // Census // Prepare counters for (i = 0; i < m; C[i++] = 0); // Census of each bucket for (i = 0; i < n; i++) C[A[i]]++; // bucket i will be <B,C[i],C[i+1]> C[m] = n; for (i = m-1; m >= 0; i--) C[i] = C[i+1]-C[i]; // Transfer to buckets for (i = 0; i < n; i++) B[C[A[i]]++] = A[i]; } In this algorithm we are performing a constant number of work per each sorted number we look at it during Census of each bucket and move it during Transfer to buckets and for each bucket to Prepare counters and to compute the bucket limits. Thus the running time is Θ(m + n) Remark. This is a stable sorting method; we do not change relative positions in the order of numbers that are equal; this is important later.

24 CSE465, Spring 2009 March 16 6 Example Array C[6]:

25 CSE465, Spring 2009 March 16 7 After census of buckets: Array C[6]:

26 CSE465, Spring 2009 March 16 8 Computing bucket s left ends: Array C[6]: Array C[6]: Array C[6]: Array C[6]: Array C[6]: Array C[6]: Array C[6]:

27 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

28 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

29 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

30 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

31 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

32 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

33 CSE465, Spring 2009 March 16 9 Transfer: 2343 Array C[6]: Array B[10]:

34 CSE465, Spring 2009 March 16 9 Transfer: 343 Array C[6]: Array B[10]:

35 CSE465, Spring 2009 March 16 9 Transfer: 43 Array C[6]: Array B[10]:

36 CSE465, Spring 2009 March 16 9 Transfer: 3 Array C[6]: Array B[10]:

37 CSE465, Spring 2009 March 16 9 Transfer: Array C[6]: Array B[10]:

38 CSE465, Spring 2009 March Radix sort We will transform Counting Sort into sorting algorithm that is good for sorting numbers in {0, 1,..., m 3 1}. A number k from this range has three digits, k = digit(k,0) + m digit(k,1) + m 2 digit(k,2). Counting_sort(A,B,n) { int C[m+1]; // Census // Prepare counters for (i = 0; i < m; C[i++] = 0); // Census of each bucket for (i = 0; i < n; i++) C[A[i]]++; // bucket i will be <B,C[i],C[i+1]> C[m] = n; for (i = m-1; m >= 0; i--) C[i] = C[i+1]-C[i]; // Transfer to buckets for (i = 0; i < n; i++) B[C[A[i]]++] = A[i]; }

39 CSE465, Spring 2009 March Radix sort We will transform Counting Sort into sorting algorithm that is good for sorting numbers in {0, 1,..., m 3 1}. A number k from this range has three digits, k = digit(k,0) + m digit(k,1) + m 2 digit(k,2). Radix_sort(A,B,n) // preliminary { int C[m+1], *S = A, *T = B, *temp; // Census // Prepare counters for (i = 0; i < m; C[i++] = 0); // Census of each bucket for (i = 0; i < n; i++) C[digit(S[i],0)]++; // bucket i will be <T,C[i],C[i+1]> C[m] = n; for (i = m-1; m >= 0; i--) C[i] = C[i+1]-C[i]; // Transfer to buckets for (i = 0; i < n; i++) T[C[digit(S[i],0)]++] = S[i]; temp = T, T = S, S = temp; } will be transformed into

40 CSE465, Spring 2009 March We can repeat what we did once more, but now wewill look at the next digit: Radix_sort(A,B,n) // still preliminary { int C[m+1], *S = A, *T = B, *temp; for (d = 0; d < 2; d++) { // Census // Prepare counters for (i = 0; i < m; C[i++] = 0); // Census of each bucket for (i = 0; i < n; i++) C[digit(S[i],d)]++; // bucket i will be <T,C[i],C[i+1]> C[m] = n; for (i = m-1; m >= 0; i--) C[i] = C[i+1]-C[i]; // Transfer to buckets for (i = 0; i < n; i++) T[C[digit(S[i],d)]++] = S[i]; temp = T, T = S, S = temp; } } will be transformed into will be transformed into

41 CSE465, Spring 2009 March Now wecan present the final version: Radix_sort(A,B,n) { int C[m+1], *S = A, *T = B, *temp; for (d = 0; d < 3; d++) { // Census // Prepare counters for (i = 0; i < m; C[i++] = 0); // Census of each bucket for (i = 0; i < n; i++) C[digit(S[i],d)]++; // bucket i will be <T,C[i],C[i+1]> C[m] = n; for (i = m-1; m >= 0; i--) C[i] = C[i+1]-C[i]; // Transfer to buckets for (i = 0; i < n; i++) T[C[digit(S[i],d)]++] = S[i]; temp = T, T = S, S = temp; } } will be transformed into will be transformed into will be transformed into

42 CSE465, Spring 2009 March Final remarks on Radix sort. We can Radix sort with any number of digits. Because we compute digits very often, it is good to compute them fast. One good way is to look at the keys that are sorted as strings of unsigned characters. This way wehave mequal to 256 and we do not compute the digits, just read them. This is particularly good if the keys are indeed strings, e.g. names to be sorted alphabetically etc. Interestingly, we can use this approach to sort positive floating point numbers: exponent byte is the most significant, when exponents are equal, we should compare mantissas. If the set to be sorted has many thousands of elements (or millions) we prefer to have fewer passes. We can use pair of bytes/characters, and characters a, b define digit a b.

43 CSE465, Spring 2009 March Lower bound on comparison sorting Counting sort and Radix sort select the place where a sorted number k should be moved based on a function of its value, e.g. digit(k, d). This assumes some knowledge about the range of objects that we are sorting, and is not necessarily useful in every possible range. Therefore we are interested in comparison sorting, i.e. in sorting algorithms in which we do not compute any fuctions of the values of the sorted objects other than comparisons, Boolean functions on pairs of objects. It is easy to show that an algorithm that sorts n numbers must perform, in the worst case, atleast log 2 (n!) comparisons. We may assume that all the objects in the input are distinct. Then there exists exactly one permutation π such that for input a 0, a 1,..., a n 1 the valid output is a π (0), a π (1),..., a π (n 1). There are n! possible permutation and anyone of them is needed for some input. Let Π be the set of permutations that are needed for one of the inputs that would give the answers to comparisons that we have seen so far. Initially, before performing any comparisons, Π = n! input is possible (and thus every permutation). because every Suppose now that we are about to perform a comparison, say a i < a j. Let Π yes be the set of permutations from Π that are consistent with the positive answer, and let Π no be the set of permutations from Π that are consistent with the negative answer. For some val {no, yes} the set Π val is at least as large as the other one. If Π is not empty, then it is possible that val is the answer to the comparison a i < a j. Thus it is possible that as the result of comparison a i < a j we change set Π into Π val and Π val Π 2 1. Consequently, it is possible that after performing k comparisons we have Π n!2 k. On the other hand, after sorting is completed, we have Π ={π} for a certain permutation π, sowehave Π = 1.

44 CSE465, Spring 2009 March Therefore if k is the largest total number of permutation performed by our unknown algorithm for some input, then n!2 k 1 1 n!2 k 2 k n! k log 2 (n!) k Σ n log 2 n. i=2 On the other hand, we can estimate the latter summation as follows: n n Σ log 2 i > log 2 x dx = 1 n 1 ln 2 ln x dx = ln 2 [x ln x x]n 1 = i=2 1 ln 2 1 (n ln n n + 1) = n log 2 n n 1 ln 2. 1

Introduction to. Algorithms. Lecture 10. Prof. Constantinos Daskalakis CLRS

Introduction to. Algorithms. Lecture 10. Prof. Constantinos Daskalakis CLRS 6.006- Introduction to Algorithms Lecture 10 Prof. Constantinos Daskalakis CLRS 8.1-8.4 Menu Show that Θ(n lg n) is the best possible running time for a sorting algorithm. Design an algorithm that sorts