×
Get Full Access to Introduction To Algorithms - 3 Edition - Chapter 8 - Problem 8-7
Get Full Access to Introduction To Algorithms - 3 Edition - Chapter 8 - Problem 8-7

×

# The 0-1 sorting lemma and columnsort A compare-exchange ISBN: 9780262033848 130

## Solution for problem 8-7 Chapter 8

Introduction to Algorithms | 3rd Edition

• Textbook Solutions
• 2901 Step-by-step solutions solved by professors and subject experts
• Get 24/7 help from StudySoup virtual teaching assistants Introduction to Algorithms | 3rd Edition

4 5 1 377 Reviews
27
4
Problem 8-7

The 0-1 sorting lemma and columnsort A compare-exchange operation on two array elements Ai and Aj , where i Aj 2 exchange Ai with Aj After the compare-exchange operation, we know that Ai Aj . An oblivious compare-exchange algorithm operates solely by a sequence of prespecified compare-exchange operations. The indices of the positions compared in the sequence must be determined in advance, and although they can depend on the number of elements being sorted, they cannot depend on the values being sorted, nor can they depend on the result of any prior compare-exchange operation. For example, here is insertion sort expressed as an oblivious compare-exchange algorithm: INSERTION-SORT.A/ 1 for j D 2 to A:length 2 for i D j 1 downto 1 3 COMPARE-EXCHANGE.A; i; i C 1/ for Chapter 8 209 The 0-1 sorting lemma provides a powerful way to prove that an oblivious compare-exchange algorithm produces a sorted result. It states that if an oblivious compare-exchange algorithm correctly sorts all input sequences consisting of only 0s and 1s, then it correctly sorts all inputs containing arbitrary values. You will prove the 0-1 sorting lemma by proving its contrapositive: if an oblivious compare-exchange algorithm fails to sort an input containing arbitrary values, then it fails to sort some 0-1 input. Assume that an oblivious compare-exchange algorithm X fails to correctly sort the array A1 : : n. Let Ap be the smallest value in A that algorithm X puts into the wrong location, and let Aq be the value that algorithm X moves to the location into which Ap should have gone. Define an array B1 : : n of 0s and 1s as follows: Bi D ( 0 if Ai Ap ; 1 if Ai > Ap : a. Argue that Aq > Ap, so that Bp D 0 and Bq D 1. b. To complete the proof of the 0-1 sorting lemma, prove that algorithm X fails to sort array B correctly. Now you will use the 0-1 sorting lemma to prove that a particular sorting algorithm works correctly. The algorithm, columnsort, works on a rectangular array of n elements. The array has r rows and s columns (so that n D rs), subject to three restrictions: r must be even, s must be a divisor of r, and r 2s2. When columnsort completes, the array is sorted in column-major order: reading down the columns, from left to right, the elements monotonically increase. Columnsort operates in eight steps, regardless of the value of n. The odd steps are all the same: sort each column individually. Each even step is a fixed permutation. Here are the steps: 1. Sort each column. 2. Transpose the array, but reshape it back to r rows and s columns. In other words, turn the leftmost column into the top r=s rows, in order; turn the next column into the next r=s rows, in order; and so on. 3. Sort each column. 4. Perform the inverse of the permutation performed in step 2. 210 Chapter 8 Sorting in Linear Time 10 14 5 8 7 17 12 1 6 16 9 11 4 15 2 18 3 13 (a) 412 835 10 7 6 12 9 11 16 14 13 18 15 17 (b) 4 8 10 12 16 18 137 9 14 15 256 11 13 17 (c) 136 257 4 8 10 9 13 15 11 14 17 12 16 18 (d) 1 4 11 3 8 14 6 10 17 2 9 12 5 13 16 7 15 18 (e) 1 4 11 2 8 12 3 9 14 5 10 16 6 13 17 7 15 18 (f) 5 10 16 6 13 17 7 15 18 1 4 11 2 8 12 3 9 14 (g) 4 10 16 5 11 17 6 12 18 1 7 13 2 8 14 3 9 15 (h) 1 7 13 2 8 14 3 9 15 4 10 16 5 11 17 6 12 18 (i) Figure 8.5 The steps of columnsort. (a) The input array with 6 rows and 3 columns. (b) After sorting each column in step 1. (c) After transposing and reshaping in step 2. (d) After sorting each column in step 3. (e) After performing step 4, which inverts the permutation from step 2. (f) After sorting each column in step 5. (g) After shifting by half a column in step 6. (h) After sorting each column in step 7. (i) After performing step 8, which inverts the permutation from step 6. The array is now sorted in column-major order. 5. Sort each column. 6. Shift the top half of each column into the bottom half of the same column, and shift the bottom half of each column into the top half of the next column to the right. Leave the top half of the leftmost column empty. Shift the bottom half of the last column into the top half of a new rightmost column, and leave the bottom half of this new column empty. 7. Sort each column. 8. Perform the inverse of the permutation performed in step 6. Figure 8.5 shows an example of the steps of columnsort with r D 6 and s D 3. (Even though this example violates the requirement that r 2s2, it happens to work.) c. Argue that we can treat columnsort as an oblivious compare-exchange algorithm, even if we do not know what sorting method the odd steps use. Although it might seem hard to believe that columnsort actually sorts, you will use the 0-1 sorting lemma to prove that it does. The 0-1 sorting lemma applies because we can treat columnsort as an oblivious compare-exchange algorithm. A Notes for Chapter 8 211 couple of definitions will help you apply the 0-1 sorting lemma. We say that an area of an array is clean if we know that it contains either all 0s or all 1s. Otherwise, the area might contain mixed 0s and 1s, and it is dirty. From here on, assume that the input array contains only 0s and 1s, and that we can treat it as an array with r rows and s columns. d. Prove that after steps 13, the array consists of some clean rows of 0s at the top, some clean rows of 1s at the bottom, and at most s dirty rows between them. e. Prove that after step 4, the array, read in column-major order, starts with a clean area of 0s, ends with a clean area of 1s, and has a dirty area of at most s2 elements in the middle. f. Prove that steps 58 produce a fully sorted 0-1 output. Conclude that columnsort correctly sorts all inputs containing arbitrary values. g. Now suppose that s does not divide r. Prove that after steps 13, the array consists of some clean rows of 0s at the top, some clean rows of 1s at the bottom, and at most 2s 1 dirty rows between them. How large must r be, compared with s, for columnsort to correctly sort when s does not divide r? h. Suggest a simple change to step 1 that allows us to maintain the requirement that r 2s2 even when s does not divide r, and prove that with your change, columnsort correctly sorts.

Step-by-Step Solution:
Step 1 of 3

Step 2 of 3

Step 3 of 3

##### ISBN: 9780262033848

Unlock Textbook Solution