package com.itheima;

import java.util.Scanner;

/*
* 7、写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
*
* 1        2        3        4
*12   13  14        5
*11   16  15        6
*10        9        8        7
*
*/

public class Test7 {

        public static void main(String[] args) {
                Test7 test = new Test7();
                // 从键盘接收一个数，动态确定数组大小
                System.out.println("请输入一个数，来作为您的二位数组维度：");
                Scanner sc = new Scanner(System.in);
                int num = sc.nextInt();
                int[][] arr = new int[num][num];
                // 数组初始值都设置为0，代表每一位还没有被访问过。
                for (int i = 0; i < num; i++) {
                        for (int j = 0; j < num; j++)
                                arr[i][j] = 0;
                }

                /*
                 * 观察得数字运动路线为：右，下，左，上。所有定义变量来记录上一个数字运动方向。 右：1 下：2 左：3 上：4
                 * .第一步肯定往右，所有move初始值为1.
                 */
                int move = 1;
                int step = 0;// 记录步数
                int i = 0, j = 0;// 初始位置

                while (step < num * num) {
                        move = test.printArr(arr, i, j, move, num);
                        switch (move) {
                        case 1:
                                arr[i][j++] = ++step;
                                break;
                        case 2:
                                arr[i++][j] = ++step;
                                break;
                        case 3:
                                arr[i][j--] = ++step;
                                break;
                        case 4:
                                arr[i--][j] = ++step;
                                break;
                        case -1:
                                break;
                        }
                }

                // 输出数组
                for (int m = 0; m < num; m++) {
                        for (int n = 0; n < num; n++) {
                                System.out.print(arr[m][n] + "   ");
                        }
                        System.out.println("");
                }
        }

        // 根据上一步的运动，以及边界条件来判断下一步该往哪个方向运动
        public int printArr(int[][] arr, int i, int j, int move, int num) {
                // 如果上一步是向右走，则判断该位置右侧是否已被访问或已达边界，是返回2，指示下一步向下走，否则返回1继续向右走
                if (move == 1) {
                        if ((j + 1) >= num || arr[i][j + 1] != 0) {
                                return 2;
                        } else
                                return 1;
                }
                // 如果上一步向下走，则判断该位置下面位置是否已被访问或已达边界，是返回3，指示下一步向左走，否返回2继续下走。
                else if (move == 2) {
                        if ((i + 1) >= num || arr[i + 1][j] != 0) {
                                return 3;
                        } else
                                return 2;
                }
                // 如果上一步向左走，则判断该位置左侧位置是否已被访问或已达边界，是返回4，指示下一步向上走，否返回3继续左走。
                else if (move == 3) {
                        if (j <= 0 || arr[i][j - 1] != 0) {
                                return 4;
                        } else
                                return 3;
                }
                // 如果上一步向上走，则判断该位置上面位置是否已被访问或已达边界，是返回1，指示下一步向右走，否返回4继续向上走。
                else if (move == 4) {
                        if (i <= 0 || arr[i - 1][j] != 0) {
                                return 1;
                        } else
                                return 4;
                }
                return -1;

        }
}

给你顶一下吧

这个是入学考试的测试题吗。。。。感觉有点长啊

给你这么辛苦的编辑点赞把

{:2_41:}入学考试如此难么,新人表示 看不懂

给你赞一个

听好玩的！

我当时考的时候误解了题意               int n = 5;
               
                int[][] arr = {{1,2,3,4,5},{16,17,18,19,6},{15,24,25,20,7},{14,23,22,21,8},{13,12,11,10,9}};
                int i = 0;
                int j = 0;
                int z = 0;
                while(z < n /2 + n % 2 ){                                   //循环的圈
                        for(j = z; j < n - z ; j++){                            //上边
                                System.out.println(arr[j]);
                        }
                        j--;
                        for(i = z + 1; i < n - z ; i++){                          //右边
                                System.out.println(arr[j]);
                        }
                        i--;
                       
                        while(j > z){
                                j--;
                                System.out.println(arr[j]);                       //下边
                        }
                       
                        while(i > z + 1){
                                i--;
                                System.out.println(arr[j]);                         //左边
                        }
               
                        z++;                                                      //开启第二轮循环
                }
        }

打印的结果是 1，2，3，4，5，6，7，8，9，10......25

给力啊！