Loading in 5 sec....

Stupid Columnsort TricksPowerPoint Presentation

Stupid Columnsort Tricks

- 73 Views
- Uploaded on
- Presentation posted in: General

Stupid Columnsort Tricks

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

Stupid Columnsort Tricks

Geeta Chaudhry

Tom Cormen

Dartmouth College

Department of Computer Science

- 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

- 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

- 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

- 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

- 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

- Each column has ≤ 1 0->1 transition
- Step 2: Transpose
- Within rows, ≤ s 0->1 transitions, ≤ s–1 1->0 transitions

- 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

- 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:

- 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

- 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)

- 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

- 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

- 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

- 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

- Another variation on columnsort
- Loosens height restriction to r ≥ 4s3/2
- Has 10 steps
- Partitions the mesh into vertical slabs

- 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