Question

I have some data coming from the hardware. Data comes in blocks of 32 bytes, and there are potentially millions of blocks. Data blocks are scattered in two halves the following way (a letter is one block):

A C E G I K M O B D F H J L N P

or if numbered

0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15

First all blocks with even indexes, then the odd blocks. Is there a specialized algorithm to reorder the data correctly (alphabetical order)?

The constraints are mainly on space. I don’t want to allocate another buffer to reorder: just one more block. But I’d also like to keep the number of moves low: a simple quicksort would be O(NlogN). Is there a faster solution in O(N) for this special reordering case?

Answer 1

Since this data is always in the same order, sorting in the classical sense is not needed at all. You do not need any comparisons, since you already know in advance which of two given data points.

Instead you can produce the permutation on the data directly. If you transform this into cyclic form, this will tell you exactly which swaps to do, to transform the permuted data into ordered data.

Here is an example for your data:

0 2 4 6 8 10 12 14 1 3  5  7  9 11 13 15
0 1 2 3 4 5  6  7  8 9 10 11 12 13 14 15

Now calculate the inverse (I’ll skip this step, because I am lazy here, assume instead the permutation I have given above actually is the inverse already).

Here is the cyclic form:

(0)(1 8 4 2)(3 9 12 6)(5 10)(7 11 13 14)(15)

So if you want to reorder a sequence structured like this, you would do

# first cycle
# nothing to do

# second cycle
swap 1 8
swap 8 4
swap 4 2

# third cycle
swap 3 9
swap 9 12
swap 12 6

# so on for the other cycles

If you would have done this for the inverse instead of the original permutation, you would get the correct sequence with a proven minimal number of swaps.

EDIT:

For more details on something like this, see the chapter on Permutations in TAOCP for example.