2d массив в спиральном порядке

Ниже функция представляет собой квадратную матрицу размера N × N, содержащую целые числа от 1 до N * N в спиральном порядке, начиная с верхнего левого угла и по часовой стрелке.

int[][] spiralNumbers(int n) {
int[][] matrix = new int[n][n];
for (int step = 0, a = 0, size; step < n/2; step++) {
    size = (n - step * 2 - 1);
    for (int i = 0, chunk, chunkIndex, chunkOffset; i < 4 * size; i++) {
        chunk = i / size;
        chunkIndex = i % size;
        chunkOffset = n - step - 1;
        switch (chunk) {
            case 0:
                matrix[step][chunkIndex + step] = a+1;
                break;
            case 1:
                matrix[chunkIndex + step][chunkOffset] = a+1;
                break;
            case 2:
                matrix[chunkOffset][chunkOffset - chunkIndex] = a+1;
                break;
            case 3:
                matrix[chunkOffset - chunkIndex][step] = a+1;
                break;
            default:
                throw new IndexOutOfBoundsException();
        }
        a++;
    }
    if (n % 2 == 1) {
        matrix[n/2][n/2] = n * n;
    }
}
return matrix; 
}

Если вы придумали код для чтения (для печати), то, конечно же, вы можете просто изменить его, чтобы он вместо этого выполнял запись, используя ту же логику?

Если вы хотите, чтобы каждая ячейка в матрице содержала свой «порядковый номер», считая в обратном порядке, что-то вроде этого должно работать, если ваша логика доступа верна:

for (int i = (m*n)-1, j = 0, index = m * n; i > 0; i--, j++) {
      for (int k = j; k < i; k++) values[j][j] = index--;
      for (int k = j; k < i; k++) values[k][i] = index--;
      for (int k = i; k > j; k--) values[i][k] = index--;
      for (int k = i; k > j; k--) values[k][j] = index--;
}

Не самый эффективный, но должен работать: g — это массив. Я также использую исключения для управления логикой.

public static void spiralFill()
{
    x = (g.length-1)/2;
    y = (g[0].length-1)/2;

    try
    {
        while(true)
        {
             east();
             south();
             step++;
             west();
             north();
             step++;        
        }
    }
    catch(ArrayIndexOutOfBoundsException e)
    {

    }
}

public static void east()
{
for(int i = 0; i < step; i++)
{
        g[x][y] = count;
        count++;
    x++;
    }
}
public static void south()
{
    for(int i = 0; i < step; i++)
    {
        g[x][y] = count;
        count++;
        y--;
    }
}   
public static void west()
{
    for(int i = 0; i < step; i++)
    {
         g[x][y] = count;
         count++;
         x--;
    }
}   
public static void north()
{
   for(int i = 0; i < step; i++)
   {
       g[x][y] = count;
       count++;
       y++;
   }
}   

Вот некоторые из вариаций:

public class SpiralMatrix {

    private static int[][] createSpiralMatrix(int size) {
        int[][] matrix = new int[size][size];

        int row = 0, col = -1;
        int value = 1;

        boolean horizontal = true;
        boolean increasing = true;
        boolean finish = false;

        while(!finish) {

            finish = true;
            if (horizontal && increasing) {
                while(tryAndSet(matrix, row, col + 1, value)) {
                    finish = false;
                    col++;
                    value++;
                }
            } else if (horizontal && !increasing) {
                while(tryAndSet(matrix, row, col - 1, value)) {
                    finish = false;
                    col--;
                    value++;
                }
            } else if (!horizontal && increasing) {
                while(tryAndSet(matrix, row + 1, col, value)) {
                    finish = false;
                    row++;
                    value++;
                }
            } else {
                while(tryAndSet(matrix, row - 1, col, value)) {
                    finish = false;
                    row--;
                    value++;
                }
            }

            if (!horizontal) {
                increasing = !increasing;
            }
            horizontal = !horizontal;
        }

        return matrix;
    }


    private static boolean tryAndSet(int[][] matrix, int row, int col, int value) {
        if (row < 0 || col < 0 || row >= matrix.length || col >= matrix[row].length || matrix[row][col] != 0) {
            return false;
        }
        matrix[row][col] = value;
        return true;
    }

    private static void printMatrix(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[i].length; j++) {
                System.out.print("\t" + matrix[i][j]);
            }
            System.out.println();
        }
    }


    public static void main(String[] args) {
        try {
            int[][] spiralMatrix = createSpiralMatrix(40);
            printMatrix(spiralMatrix);
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }