[amel27]

1. Хорошо бы иметь таблицу преобразования (ТП) между координатами элемента в матрице и положением в одномерном массиве "раскрученной спирали", тогда заполнение выполняется за один проход... К примеру для матрицы 3x3 таблица преобразования будет (x,y) = {(1,2) (1,3) (2,3) (3,3) (3,2) (3,1) (2,1) (2,2)}, т.е. по сути это двумерный массив указателей.

2. Теперь как можно построить ТП. Допустим, мы можем построить ее для одного оборота обхода матрицы (MxN) начав с левого верхнего угла, т.е. имеем ф-цию Fun (N, M, I, J), добавляющую в конец глобальной ТП координаты обхода (I, J - "координаты" начала обхода). Так вот, полный путь состоит из последовательности: Fun (N,M, 0,0) --> Fun (N-2,M-2, 1,1) --> Fun (N-4,M-4, 2,2) ... пока размерность массива >0.

3. Алгоритм Fun (M, N, I, J) линеен и состоит из четырех отрезков:
- y=J, x увеличивается от I до I+N-1
- x=I+N-1, y увеличивается от J до J+M-1
- y=J+M-1, x уменьшается от x=I+N-1 до I
- x=I, y уменьшается от J+M-1 до J+1

З.Ы. Это только общий алгоритм... Звиняюсь, но из вашего кода я мало чего понял, и про "четверти" с "поворотами" тоже.

[mrcnn]

З.Ы. Это только общий алгоритм... Звиняюсь, но из вашего кода я мало чего понял, и про "четверти" с "поворотами" тоже.

Полный поворот для матрицы 3x3 это проход от a(1,1) до a(2,1) - по 2 строкам и 2 столбцам
Три четверти поворота это проход от a(1,1) до a(3,1) - по 2 строкам и столбцу

В коде делается следующее.
Задаются начальные значения позиции в матрице и конечные значения:
1. проход по первой строке (четверть от полного поворота по часовой стрелке от a(1,1) до a(1,1)). После каждой четверти поворота меняем начальные значения на конечные. Строка(y) фиксируется, столбцы(x) меняются.
2. проход по последнему столбцу (вторая четверть поворота). Столбец(x) фиксируется, строки(y) меняются.
3. проход по последней строке (четверть поворота - всего 3/4 поворота)

Заводится цикл, зависящий от переменной, показывающей четный или нечетный проход, чтобы знать, надо ли уменьшать индексы или нет:
1. проход по столбцу
2. проход по строке
После каждого полного поворота уменьшается счетчик, показывающий конечные значения

По-моему вы предложили то же самое..
Есть ли еще какие-нибудь способы?

[pva]

есть, их полно. Правда чем дальме - тем более извращённый способ получается.
Например, сведём всё к одной операции прохода строчки и одной операции поворота матрицы (всё это в цикле).

в цикле:
1. прошли верхнюю строчку
2. повернули на 90 CCW (кто фотошоп видел, поймёт)

дальше варианты: копировать матрицу или поворачивать координатную ось. Дешевле повернуть ось (понятней - наоборот). Так и сделаем!

Код:

// извиняюсь, что пишу не на языке вопроса, но если идея зацепит, попробую перевести
class pass_matrix
{
    static const int gwidth = 10;  // начальная ширина
    static const int gheight = 20; // начальная высота

    int matrix[gwidth*gheight];

    int width;  // ширина
    int height; // высота
    int a, b, c, d; // преобразование координат
        // x1 = a*x + b
        // y1 = c*y + d
    int x, y;  // смещение

    void print()
    {
        std::cout << "{" << x << ", " << y << "}: "
                << matrix[x + y*qwidth] << "\n";
    }

public:
    pass_matrix() :
        matrix(),
        width(gwidth),
        height(gheight),
        a(1), b(0),
        c(1), d(0),
        x(0), y(0)
    {
        // начальная позиция:
        //  0123
        // 0x->.
        // 1....
        // 2....
    }
private:

    void step()
    {
        // делаем один шаг
        x += a;
        y += b;
    }

    void rotate()
    {
        // шаг назад
        //  0123
        // 0....x
        // 1...|
        // 2...v
        x += c - a;
        y += d - b;

        // поворот матрицы (направления)
        int a1 = c;
        int b1 =  d;
        int c1 = -a;
        int d1 =  -b;

        a = a1;
        b = b1;
        c = c1;
        d = d1;

        // поворот и усечение размеров
        --height;
        std::swap(width,height);
    }

public:
    void main()
    {
        while (0<height)
        {
            for (int w=width; 0<=--w; step())
            {
                print();
            }

            rotate();
        }
    }
};

если в линейных преобразованиях не напутал, то должно работать