Сортировка списка в несколько вертикальных столбцов

Хорошо, я сожалею о своем начальном операторе, но когда Вы хотите, чтобы он работал, как Вы описали в комментарии к моему первому ответу, Вы должны на самом деле обратиться данные... хорошо несколько. Это могло, возможно, быть сделано без матрицы помощника, однако получающийся код, вероятно, очень сложен и, пока матрица будет только использовать несколько байтов памяти, почему не использование этого маленького помощника создает?

То, что мой код делает ниже, создает матрицу. Мы пишем матрицу сверху донизу и затем слева направо (и прекращаем заполнять что-либо кроме первой строки, когда у нас заканчиваются элементы для заполнения всех столбцов первой строки). Затем мы читаем его в другом порядке, слева направо и от начала до конца. В основном то, что мы делаем здесь, транспонирует матрицу, путем записи этого в одном порядке, но читает его в другом порядке. Перемещение матрицы является очень элементарной математической операцией (много 3D работ программирования при помощи матричных вычислений, и перемещение является на самом деле простой операцией). Прием - то, как мы первоначально заполняем матрицу. Для проверки мы можем заполнить первый столбец в любом случае, независимо от количества требуемых столбцов и размера массива, мы должны прекратить заполнять матрицу в нормальном порядке, если мы заканчиваемся элементы и резервируем все элементы, перенесенные для первой строки. Это произведет вывод, который Вы предложили в своем комментарии.

Все это - сложный бит честно говоря, но теория позади него должна быть нормальной, и он работает прекрасный :-D

int Columns;
char * Array[] = {"A", "B", "C", "D", "E", "F", "G"};

int main (
    int argc,
    char ** argv
) {
    // Lets thest this with all Column sizes from 1 to 7
    for (Columns = 1; Columns <= 7; Columns++) {

        printf("Output when Columns is set to %d\n", Columns);

        // This is hacky C for quickly get the number of entries
        // in a static array, where size is known at compile time
        int arraySize = sizeof(Array) / sizeof(Array[0]);

        // How many rows we will have
        int rows = arraySize / Columns;

        // Below code is the same as (arraySize % Columns != 0), but
        // it's almost always faster
        if (Columns * rows != arraySize) {
            // We might have lost one row by implicit rounding
            // performed for integer division
            rows++;
        }

        // Now we create a matrix large enough for rows * Columns
        // references. Note that this array could be larger than arraySize!
        char ** matrix = malloc(sizeof(char *) * rows * Columns);

        // Something you only need in C, C# and Java do this automatically:
        // Set all elements in the matrix to NULL(null) references
        memset(matrix, 0, sizeof(char *) * rows * Columns );

        // We fill up the matrix from top to bottom and then from
        // left to right; the order how we fill it up is very important
        int matrixX;
        int matrixY;
        int index = 0;
        for (matrixX = 0; matrixX < Columns; matrixX++) {
            for (matrixY = 0; matrixY < rows; matrixY++) {
                // In case we just have enough elements left to only
                // fill up the first row of the matrix and we are not
                // in this first row, do nothing.
                if (arraySize + matrixX + 1 - (index + Columns) == 0 &&
                        matrixY != 0) {
                    continue;
                }

                // We just copy the next element normally
                matrix[matrixY + matrixX * rows] = Array[index];
                index++;
                //arraySize--;
            }
        }

        // Print the matrix exactly like you'd expect a matrix to be
        // printed to screen, that is from left to right and top to bottom;
        // Note: That is not the order how we have written it,
        // watch the order of the for-loops!
        for (matrixY = 0; matrixY < rows; matrixY++) {
            for (matrixX = 0; matrixX < Columns; matrixX++) {
                // Skip over unset references
                if (matrix[matrixY + matrixX * rows] == NULL)
                    continue;

                printf("%s", matrix[matrixY + matrixX * rows]);
            }
            // Next row in output
            printf("\n");
        }
        printf("\n");

        // Free up unused memory
        free(matrix);
    }   
    return 0;
}

Вывод

Output when Columns is set to 1
A
B
C
D
E
F
G

Output when Columns is set to 2
AE
BF
CG
D

Output when Columns is set to 3
ADG
BE
CF

Output when Columns is set to 4
ACEG
BDF

Output when Columns is set to 5
ACEFG
BD

Output when Columns is set to 6
ACDEFG
B

Output when Columns is set to 7
ABCDEFG

Этот код C должен быть легким к порту к PHP, C#, Java, и т.д., нет никакого большого включенного волшебства, таким образом, это является в значительной степени универсальным, портативным и межплатформенным.

Одна важная вещь я должен добавить:

Этот код откажет, если Вы обнулите Столбцы (деление на нуль, я не проверяю на тот), но какой смысл 0 столбцов имели бы? И это также откажет, если у Вас будет больше столбцов, чем элементы в массиве, я не проверяю на это также. Можно легко проверить на любое право после того, как Вы получили arraySize:

if (Columns <= 0) {
   // Having no column make no sense, we need at least one!
   Columns = 1;
} else if (Columns > arraySize) {
   // We can't have more columns than elements in the array!
   Columns = arraySize;
}

Далее необходимо также проверить на arraySize быть 0, в этом случае можно немедленно выскочить функции, как в этом случае нет абсолютно ничего, чтобы сделать для функции :) Добавление этих проверок должно заставить код качать тело.

Наличие ПУСТЫХ Элементов в Массиве будет работать, BTW, в этом случае в получающемся выводе нет никаких дыр. ПУСТЫЕ элементы просто пропускаются как не присутствование. Например, позволяет использованию

char * Array[] = {"A", "B", "C", "D", "E", NULL, "F", "G", "H", "I"};

Вывод будет

ADFI
BEG
CH

для Столбцов == 4. Если Вы хотите дыры, необходимо создать элемент дыры.

char hole = 0;
char * Array[] = {"A", "B", &hole, "C", "D", "E", &hole, "F", "G", "H", "I"};

и измените рисование, кодируют немного

    for (matrixY = 0; matrixY < rows; matrixY++) {
        for (matrixX = 0; matrixX < Columns; matrixX++) {
            // Skip over unset references
            if (matrix[matrixY + matrixX * rows] == NULL)
                continue;

            if (matrix[matrixY + matrixX * rows] == &hole) {
                printf(" ");
            } else {
                printf("%s", matrix[matrixY + matrixX * rows]);
            }
        }
        // Next row in output
        printf("\n");
    }
    printf("\n");

Выходные образцы:

Output when Columns is set to 2
A 
BF
 G
CH
DI
E

Output when Columns is set to 3
ADG
BEH
  I
CF

Output when Columns is set to 4
AC H
BDFI
 EG