Stupid columnsort tricks
This presentation is the property of its rightful owner.
Sponsored Links
1 / 16

Stupid Columnsort Tricks PowerPoint PPT Presentation


  • 58 Views
  • Uploaded on
  • Presentation posted in: General

Stupid Columnsort Tricks. Geeta Chaudhry Tom Cormen Dartmouth College Department of Computer Science. Columnsort. Sorts N numbers Organized as r ´ s mesh Divisibility restriction : s must divide r Height restriction : r ≥ 2 s 2 8 steps Sort each column Transpose

Download Presentation

Stupid Columnsort Tricks

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Stupid columnsort tricks

Stupid Columnsort Tricks

Geeta Chaudhry

Tom Cormen

Dartmouth College

Department of Computer Science


Columnsort

Columnsort

  • Sorts N numbers

    • Organized as r´s mesh

    • Divisibility restriction: s must divide r

    • Height restriction: r ≥ 2s2

  • 8 steps

    • Sort each column

    • Transpose

    • Sort each column

    • Untranspose

    • Sort each column

    • Shift down 1/2 column

    • Sort each column

    • Shift up 1/2 column


Proof of correctness

Proof of Correctness

  • Columnsort is oblivious

    • Use 0-1 Principle:If an oblivious algorithm sorts all input sets consisting solely of 0s and 1s, then it sorts all input sets with arbitrary values.

  • After step 3, the mesh consists of

    • Clean rows of 0s at the top

    • Clean rows of 1s at the bottom

    • ≤ s dirty rows between the clean rows


Proof of correctness continued

Proof of Correctness (continued)

  • After step 4, the mesh consists of

    • Clean columns of 0s on the left

    • Clean columns of 1s on the right

    • A dirty area of size ≤ s2 between the clean columns

  • r ≥ 2s2 ==> s2 ≤ r/2==> the dirty area is at most 1/2 a column large


Proof of correctness continued1

Proof of Correctness (continued)

  • If, entering step 5, the dirty area is at most 1/2 a column large, then steps 5–8 complete the sorting

    • If the dirty area fits in a single column, step 5 cleans it, and steps 6–8 leave the mesh clean

    • If the dirty area spans two columns, then it’s in the bottom half of one column and the top half of the next column.

      • Step 5 does not change this

      • Step 6 gets the dirty area into one column

      • Step 7 cleans it

      • Step 8 moves all values back to where they belong


Removing the divisibility restriction

Removing the Divisibility Restriction

  • Step 1: Sort each column

    • Each column has ≤ 1 0->1 transition

      • ≤ s 0->1 transitions

    • There may be a 1->0 transition going from one column to the next

      • ≤ s–1 1->0 transitions

  • Step 2: Transpose

    • Within rows, ≤ s 0->1 transitions, ≤ s–1 1->0 transitions


Divisibility restriction continued

Divisibility Restriction (continued)

  • After step 2, let

    • X = dirty rows with one 0->1 transition, no 1->0

    • Y = dirty rows with one 1->0 transition, no 0->1

    • Z = all other dirty rows (≥ 1 0->1 and ≥ 1 1->0)

    • Number of dirty rows = |X| + |Y| + |Z|

    • All other rows are clean

  • Claim: max(|X|, |Y|) + |Z| ≤ s

    • Every row of X, Z contains ≥ 1 0->1 => |X| + |Z| ≤ s

    • Every row of Y, Z contains ≥ 1 1->0 => |Y| + |Z| ≤ s–1

    • max(|X|, |Y|) = |X| => max(|X|, |Y|) + |Z| ≤ s

    • max(|X|, |Y|) = |Y| => max(|X|, |Y|) + |Z| ≤ s–1

    • In either case, max(|X|, |Y|) + |Z| ≤ s


Divisibility restriction continued1

Divisibility Restriction (continued)

  • After step 3

    • Clean rows of 0s move to the top

    • Clean rows of 1s move to the bottom

    • Pair up the min(|X|, |Y|) pairs of rows with one row in X and other row in Y

more 0s than 1s

000000001111

111110000000

000000000000

111110001111

more 1s than 0s

000111111111

111111110000

000111110000

111111111111

equal 0s and 1s

000011111111

111100000000

000000000000

111111111111

from X:

from Y:


Divisibility restriction continued2

Divisibility Restriction (continued)

  • In all cases, ≥ 1 clean row is formed

  • ≥ min(|X|, |Y|) new clean rows are created

  • Dirty rows remaining≤ |X| + |Y| + |Z| – min(|X|, |Y|)

  • |X| + |Y| – min(|X|, |Y|) = max(|X|, |Y|)==> Dirty rows remaining ≤ max(|X|, |Y|) + |Z| ≤ s

  • From here, it’s the same as the original proof

    • Dirty area size ≤ s2 ≤ r/2 (half a column) after step 4

    • Steps 5–8 clean up the dirty area


Subblock distribution

Subblock Distribution

  • Divide up the mesh into s1/2´s1/2 subblocks

    • Each subblock contains s values

  • Add two steps between steps 3 and 4

    • Step 3.1: Perform any fixed permutation that moves all values in each subblock into all s columns

    • Step 3.2: Sort each column

  • The resulting algorithm is subblock columnsort

  • Works with relaxed height restriction of r ≥ 4s3/2 (assuming the divisibility restriction)


Subblock columnsort correctness

Subblock Columnsort Correctness

  • After step 3, the line dividing 0s and 1s goes left to right and bottom to top (southwest to northeast)

    • Never turns back to the left

    • Never turns back toward the bottom

    • To show, suffices to show that after step 2,# of 0s in each column ≥ # of 0s in column to its right

    • How could a column have# of 0s < # of 0s in column to its right?

    • There would have to be a 1->0 transition in a row

    • But divisibility restriction => there are no 1->0 transitions in rows after step 2


Subblock columnsort correctness continued

Subblock Columnsort Correctness (continued)

  • After step 3.1, the number of 0s in any two columns differs by ≤ 2s1/2

    • The dirty area is confined to an area s rows high and s columns wide

    • In subblocks, s1/2´s1/2

    • Dividing line passes through ≤ s1/2 + 1 subblocks vertically and ≤ s1/2 subblocks horizontally ==> ≤ 2s1/2 subblocks total

      • Don’t double-count the 1 extra subblock

    • Step 3.1 distributes each subblock to all s columns

    • All clean subblocks distribute their 0s and 1s uniformly to each column

    • Number of 0s between any two columns differs by≤ number of dirty subblocks = 2s1/2


Subblock columnsort correctness continued1

Subblock Columnsort Correctness (continued)

  • After step 4, the mesh consists of

    • Clean columns of 0s on the left

    • Clean columns of 1s on the right

    • A dirty area of size ≤ 2s3/2 between the clean columns

  • After sorting in step 3.2, the dirty area is≤ 2s1/2 rows high and ≤ s columns wide

  • Size of dirty area is ≤ 2s3/2


Subblock columnsort correctness continued2

Subblock Columnsort Correctness (continued)

  • Finish up by observing that r ≥ 4s3/2 is equivalent to 2s3/2 ≤ r/2

  • Now the dirty area is at most 1/2 a column

  • Steps 5–8 clean up the dirty area

  • Can remove the divisibility restriction at the cost of tightening the height restriction to r ≥ 6s3/2


Slabpose columnsort

Slabpose Columnsort

  • Another variation on columnsort

  • Loosens height restriction to r ≥ 4s3/2

  • Has 10 steps

  • Partitions the mesh into vertical slabs


Conclusion

Conclusion

  • Removed and relaxed restrictions on columnsort

    • Divisibility restriction: s divides r

    • Height restriction: r ≥ 2s2

  • Divisibility restriction is not necessary

  • Subblock columnsort

    • With divisibility restriction: r ≥ 4s3/2

    • Without divisibility restriction: r ≥ 6s3/2

  • Slabpose columnsort: r ≥ 4s3/2


  • Login