Algorithms and data structures

Transcription

1 Algorithms and data structures Amin Coja-Oghlan LFCS

2 Sorting n numbers in time O(n) A paradox? In the last lecture we derive a Ω(n lnn) lower bound on the running time of comparison based sorting algorithms. The lower bound was based on sorting a permutation of {1,...,n}. In this lecture we will see how to solve this problem in time O(n)......but the sorting algorithm is not comparison based. A. Coja-Oghlan (LFCS) Algorithms and data structures 2 / 11

3 Sorting n numbers in time O(n) A paradox? In the last lecture we derive a Ω(n lnn) lower bound on the running time of comparison based sorting algorithms. The lower bound was based on sorting a permutation of {1,...,n}. In this lecture we will see how to solve this problem in time O(n)......but the sorting algorithm is not comparison based. Algorithm SimpleCountingSort(A) Input: an array A of size n that contains numbers from {1,...,n}. Output: sorted version of A. 1 Set N [i] = 0 for all 1 i n. 2 For i = 1,...,n let N [A [i]] = N [A [i]] For i = 1,...,n output the number i exactly N [i] times. A. Coja-Oghlan (LFCS) Algorithms and data structures 2 / 11

4 CountingSort Can we generalize this approach? Let us assume that the array A contains objects. Each object A [i] has a key A [i].key. The keys are integers in {1,...,m}. A. Coja-Oghlan (LFCS) Algorithms and data structures 3 / 11

5 CountingSort Can we generalize this approach? Let us assume that the array A contains objects. Each object A [i] has a key A [i].key. The keys are integers in {1,...,m}. CountingSort: idea Count for each key 1 j m how often it occurs; store results in an array C. Use C to determine the position of each element in the sorted array: elements with key j go to positions 1 + j 1 i=1 C [i],..., j i=1 C [i]. Do something clever to actually move the objects to the right positions... A. Coja-Oghlan (LFCS) Algorithms and data structures 3 / 11

6 CountingSort (ctd.) Algorithm CountingSort(A, m) Input: an array A of size n with keys in {1,...,m}. Output: sorted array. 1 Initialize C [j] = 0 for all 1 j m. 2 For i = 1,...,n increase C [A [i].key] by one. 3 For j = 2,...,m let C [j] = C [j 1] + C [j] // now C [j] = #elements with key j A. Coja-Oghlan (LFCS) Algorithms and data structures 4 / 11

7 CountingSort (ctd.) Algorithm CountingSort(A, m) Input: an array A of size n with keys in {1,...,m}. Output: sorted array. 1 Initialize C [j] = 0 for all 1 j m. 2 For i = 1,...,n increase C [A [i].key] by one. 3 For j = 2,...,m let C [j] = C [j 1] + C [j] // now C [j] = #elements with key j 4 For i = n,n 1,...,1 do 5 let j = A [i].key, B [C [ j ]] = A [i], and decrease C [j ] by one. // B is an auxiliary array to store sorted sequence A. Coja-Oghlan (LFCS) Algorithms and data structures 4 / 11

8 CountingSort (ctd.) Algorithm CountingSort(A, m) Input: an array A of size n with keys in {1,...,m}. Output: sorted array. 1 Initialize C [j] = 0 for all 1 j m. 2 For i = 1,...,n increase C [A [i].key] by one. 3 For j = 2,...,m let C [j] = C [j 1] + C [j] // now C [j] = #elements with key j 4 For i = n,n 1,...,1 do 5 let j = A [i].key, B [C [ j ]] = A [i], and decrease C [j ] by one. // B is an auxiliary array to store sorted sequence 6 For i = 1,...,n let A [i] = B [i]. // store the sorted sequence back into A 7 Output A. A. Coja-Oghlan (LFCS) Algorithms and data structures 4 / 11

9 CountingSort (ctd.) The running time Lines 2, 4 5, and 6 require time O(n). Lines 1 and 3 take time O(m). Thus, the total running time is O(n + m). A. Coja-Oghlan (LFCS) Algorithms and data structures 5 / 11

10 CountingSort (ctd.) The running time Lines 2, 4 5, and 6 require time O(n). Lines 1 and 3 take time O(m). Thus, the total running time is O(n + m). Stable sorting A sorting algorithm is stable if it leaves elements with the same keys in the original order (i.e., just as in the input). CountingSort is stable. (QuickSort is not.) A. Coja-Oghlan (LFCS) Algorithms and data structures 5 / 11

11 RadixSort Basic assumptions The keys are sequences of digits. Each sequence has the same length d. The digits belong to a fixed range 0,...,R 1. A. Coja-Oghlan (LFCS) Algorithms and data structures 6 / 11

12 RadixSort Basic assumptions The keys are sequences of digits. Each sequence has the same length d. The digits belong to a fixed range 0,...,R 1. Examples of such keys US zip codes (5 decimal digits). UK zip codes (fixed length ASCII character sequences). Generally, fixed length bit sequences. A. Coja-Oghlan (LFCS) Algorithms and data structures 6 / 11

13 RadixSort (ctd.) Idea Sort the keys digit-wise, starting with the rightmost (=least significant) digit. now for tip ilk dim tag jot sob nob sky hut ace bet sob nob ace tag ilk dim tip for jot hut bet now sky tag ace bet dim tip sky ilk sob nob for jot now hut ace bet dim for hut ilk jot nob now sky sob tag tip A. Coja-Oghlan (LFCS) Algorithms and data structures 7 / 11

14 RadixSort (ctd.) Algorithm RadixSort(A, d) Input: an array A and the key length d. Output: sorted A. 1 for i = 1,...,d do 2 apply CountingSort using the i th digit from the right as key. 3 Output A. A. Coja-Oghlan (LFCS) Algorithms and data structures 8 / 11

15 RadixSort (ctd.) Algorithm RadixSort(A, d) Input: an array A and the key length d. Output: sorted A. 1 for i = 1,...,d do 2 apply CountingSort using the i th digit from the right as key. 3 Output A. Running time Each execution of Step 2 takes time O(n + R). Total running time: O(d(n + R)). A. Coja-Oghlan (LFCS) Algorithms and data structures 8 / 11

16 RadixSort (ctd.) Theorem An array of length n whose keys are b-bit numbers can be sorted in time O(n b/log 2 n ). Proof. Use RadixSort. The digits are blocks of log 2 n bits. Thus, R = 2 log 2 n = O(n) and d = b/log 2 n. Total running time: O(d(n + R)) = O(n b/log 2 n ). A. Coja-Oghlan (LFCS) Algorithms and data structures 9 / 11

17 RadixSort (ctd.) Corollary Let k be a constant. The problem of sorting n keys from the range {0,1,...,n k } can be solved in time O(n). Proof. Use the previous theorem. The keys can be represented by b = 1 + log 2 (n k ) = 1 + k log 2 n bits. Hence, the total running time is O(n k log 2 n/log 2 n ) = O(k n) = O(n). The last step follows from the assumption that k remains fixed (as n grows). The constant hidden in the O depends on k. For small n the constants matter, because lnn grows slowly. A. Coja-Oghlan (LFCS) Algorithms and data structures 10 / 11

18 Reading assignment Take a glimpse at... [CLRS] chapter 8. A. Coja-Oghlan (LFCS) Algorithms and data structures 11 / 11