Java数组算法——“回形数”或“回形矩阵” （数组元素的赋值类别算法）

介绍：

从键盘输入一个整数（1~20） 

则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。

例如： 输入数字2，则程序输出：

1    2    
4    3    

输入数字3，则程序输出： 

1    2    3    
8    9    4    
7    6    5

输入数字4， 则程序输出： 

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

图示：

 

代码：

写法一（方向思路）：

public class Main {
    private static final int RIGHT = 1;  //向右
    private static final int DOWN = 2;   //向下
    private static final int LEFT = 3;   //向左
    private static final int ON = 4;     //向上
    /*
     * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
     */

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数字");
        int num = scanner.nextInt();
        int[][] huiXingShu = new int[num][num];

        int count = num * num; //s表示该矩阵的总数目

        int k = RIGHT; //k变量表示往哪个方向赋值  初始化从向右开始
        int i = 0, j = 0; //i表示数组的纵坐标  j表示数组的横坐标
        for (int m = 1; m <= count; m++) {  //循环的次数刚好是矩阵的总数目
            if (k == RIGHT) {   //向右    赋值限制条件：如果横坐标小于输入的矩阵纵横数并且值是默认值0就给它赋值
                if (j < num && huiXingShu[i][j] == 0) {
                    huiXingShu[i][j++] = m;
                } else {    //如果不是
                    k = DOWN;  //表示改变方向赋值  向下
                    i++;    //每次方向赋值完 要换一行方便下个判断赋值 所以i自增1 保证下次循环i下标是正确的
                    j--;    //每次方向赋值完 要帮上面j++多运行的一次自减1 保证下次循环j下标是正确的
                    m--;    //每次方向赋值完 进入else语句都要自减1 保证下次循环m的赋值数是正确的
                }
            } else if (k == DOWN) {    //向下   以下同理
                if (i < num && huiXingShu[i][j] == 0) { 
                    huiXingShu[i++][j] = m;
                } else {
                    k = LEFT;
                    i--;
                    j--;
                    m--;
                }
            } else if (k == LEFT) {    //向左
                if (j >= 0 && huiXingShu[i][j] == 0) {
                    huiXingShu[i][j--] = m;
                } else {
                    k = ON;
                    i--;
                    j++;
                    m--;
                }
            } else if (k == ON) {    //向上
                if (i >= 0 && huiXingShu[i][j] == 0) {
                    huiXingShu[i--][j] = m;
                } else {
                    k = RIGHT;
                    i++;
                    j++;
                    m--;
                }
            }
        }

        // 遍历
        for (int[] anArr : huiXingShu) {
            for (int anAnArr : anArr) {
                System.out.print(anAnArr + "\t");
            }
            System.out.println();
        }
    }
}

写法二（下标思路）：

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数字");
        int num = scanner.nextInt();
        int[][] huiXingShu = new int[num][num];

        int count = 0; // 要显示的数据
        int maxX = num - 1; // x横轴的最大下标
        int maxY = num - 1; // Y纵轴的最大下标
        int minX = 0; // x横轴的最小下标
        int minY = 0; // Y纵轴的最小下标
        while (minX <= maxX) {  //直到X横轴线最小下标比最大下标还大时就退出循环 说明已经把值赋到最后一个了
            for (int x = minX; x <= maxX; x++) {    //向右 从最小到最大下标递增
                huiXingShu[minY][x] = ++count;  //必须++count 不然count++第一次会赋值为0
            }
            minY++;     //说明Y纵轴的最小下标+1 向右已经赋值完一行了
            for (int y = minY; y <= maxY; y++) {    //向下 从最小到最大下标递增
                huiXingShu[y][maxX] = ++count;
            }
            maxX--;     //以上同理不再赘述
            for (int x = maxX; x >= minX; x--) {    //向左 从最小到最大下标递减
                huiXingShu[maxY][x] = ++count;
            }
            maxY--;
            for (int y = maxY; y >= minY; y--) {    //向上 从最小到最大下标递减
                huiXingShu[y][minX] = ++count;
            }
            minX++;
        }

        // 遍历
        for (int[] anhuiXingShu : huiXingShu) {
            for (int anAnhuiXingShu : anhuiXingShu) {
                System.out.print(anAnhuiXingShu + "\t");
            }
            System.out.println();
        }
    }
}