有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

1. public class Test9 {
   
2. 
   
3.         /**
   
4.          *  写一方法，打印等长的二维数组，
   
5.          * 要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
   
6.          * 1  2  3    4
   
7.          * 12 13 14   5
   
8.          * 11 16 15   6
   
9.          * 10 9  8    7
   
10.          *                                 
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 Test9 test = new Test9();
    
14.                 //从键盘接收一个数，动态确定数组大小
    
15.                 System.out.println("请输入一个数，来作为您的二位数组维度：");
    
16.                
    
17.                 Scanner sc = new Scanner(System.in);
    
18.                 int num = sc.nextInt();
    
19.                 int[][] arr = new int[num][num];
    
20.                
    
21.                 //数组初始值都设置为0，代表每一位还没有被访问过。
    
22.                 for(int i=0;i<num;i++){
    
23.                         for(int j=0;j<num;j++)
    
24.                                 arr[i][j] = 0;
    
25.                 }
    
26.                
    
27.                 /*观察得数字运动路线为：右，下，左，上。所有定义变量来记录上一个数字运动方向。
    
28.                   右：1  下：2  左：3 上：4 .第一步肯定往右，所有move初始值为1.
    
29.                  */
    
30.                 int move =1;
    
31.                 int step =0;//记录步数
    
32.                 int i=0,j=0;//初始位置
    
33.        
    
34.                 while(step < num*num){
    
35.                         move = test.printArr(arr, i, j, move, num);
    
36.                         switch(move){
    
37.                                 case 1:
    
38.                                         arr[i][j++] = ++step;                               
    
39.                                         break;
    
40.                                 case 2:
    
41.                                         arr[i++][j] = ++step;                               
    
42.                                         break;
    
43.                                 case 3:
    
44.                                         arr[i][j--] = ++step;                               
    
45.                                         break;
    
46.                                 case 4:
    
47.                                         arr[i--][j] = ++step;                               
    
48.                                         break;
    
49.                                 case -1:
    
50.                                         break;
    
51.                         }
    
52.                 }
    
53.        
    
54.                 //输出数组
    
55.                 for(int m=0;m<num;m++){
    
56.                         for(int n=0;n<num;n++){
    
57.                                 System.out.print(arr[m][n]+"   ");
    
58.                         }               
    
59.                         System.out.println("");
    
60.                 }
    
61.         }
    
62.        
    
63.         //根据上一步的运动，以及边界条件来判断下一步该往哪个方向运动
    
64.         public int printArr(int[][]arr,int i,int j,int move,int num){
    
65.                 //如果上一步是向右走，则判断该位置右侧是否已被访问或已达边界，是返回2，指示下一步向下走，否则返回1继续向右走
    
66.                 if(move == 1){
    
67.                         if((j+1)>=num || arr[i][j+1] !=0){
    
68.                                 return 2;
    
69.                         }
    
70.                         else return 1;
    
71.                 }
    
72.                 //如果上一步向下走，则判断该位置下面位置是否已被访问或已达边界，是返回3，指示下一步向左走，否返回2继续下走。
    
73.                 else if(move == 2){
    
74.                         if((i+1)>=num || arr[i+1][j] != 0){
    
75.                                 return 3;
    
76.                         }
    
77.                         else return 2;
    
78.                 }
    
79.                 //如果上一步向左走，则判断该位置左侧位置是否已被访问或已达边界，是返回4，指示下一步向上走，否返回3继续左走。
    
80.                 else if(move == 3){
    
81.                         if(j<=0 || arr[i][j-1] != 0){
    
82.                                 return 4;
    
83.                         }
    
84.                         else return 3;
    
85.                 }
    
86.                 //如果上一步向上走，则判断该位置上面位置是否已被访问或已达边界，是返回1，指示下一步向右走，否返回4继续向上走。
    
87.                 else if(move == 4){
    
88.                         if(i<=0 || arr[i-1][j] != 0){
    
89.                                 return 1;
    
90.                         }
    
91.                         else return 4;
    
92.                 }
    
93.                 return -1;
    
94.                
    
95.         }
    
96. }
    

复制代码

有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

1. public class Test9 {
   
2. 
   
3.         /**
   
4.          *  写一方法，打印等长的二维数组，
   
5.          * 要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
   
6.          * 1  2  3    4
   
7.          * 12 13 14   5
   
8.          * 11 16 15   6
   
9.          * 10 9  8    7
   
10.          *                                 
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 Test9 test = new Test9();
    
14.                 //从键盘接收一个数，动态确定数组大小
    
15.                 System.out.println("请输入一个数，来作为您的二位数组维度：");
    
16.                
    
17.                 Scanner sc = new Scanner(System.in);
    
18.                 int num = sc.nextInt();
    
19.                 int[][] arr = new int[num][num];
    
20.                
    
21.                 //数组初始值都设置为0，代表每一位还没有被访问过。
    
22.                 for(int i=0;i<num;i++){
    
23.                         for(int j=0;j<num;j++)
    
24.                                 arr[i][j] = 0;
    
25.                 }
    
26.                
    
27.                 /*观察得数字运动路线为：右，下，左，上。所有定义变量来记录上一个数字运动方向。
    
28.                   右：1  下：2  左：3 上：4 .第一步肯定往右，所有move初始值为1.
    
29.                  */
    
30.                 int move =1;
    
31.                 int step =0;//记录步数
    
32.                 int i=0,j=0;//初始位置
    
33.        
    
34.                 while(step < num*num){
    
35.                         move = test.printArr(arr, i, j, move, num);
    
36.                         switch(move){
    
37.                                 case 1:
    
38.                                         arr[i][j++] = ++step;                               
    
39.                                         break;
    
40.                                 case 2:
    
41.                                         arr[i++][j] = ++step;                               
    
42.                                         break;
    
43.                                 case 3:
    
44.                                         arr[i][j--] = ++step;                               
    
45.                                         break;
    
46.                                 case 4:
    
47.                                         arr[i--][j] = ++step;                               
    
48.                                         break;
    
49.                                 case -1:
    
50.                                         break;
    
51.                         }
    
52.                 }
    
53.        
    
54.                 //输出数组
    
55.                 for(int m=0;m<num;m++){
    
56.                         for(int n=0;n<num;n++){
    
57.                                 System.out.print(arr[m][n]+"   ");
    
58.                         }               
    
59.                         System.out.println("");
    
60.                 }
    
61.         }
    
62.        
    
63.         //根据上一步的运动，以及边界条件来判断下一步该往哪个方向运动
    
64.         public int printArr(int[][]arr,int i,int j,int move,int num){
    
65.                 //如果上一步是向右走，则判断该位置右侧是否已被访问或已达边界，是返回2，指示下一步向下走，否则返回1继续向右走
    
66.                 if(move == 1){
    
67.                         if((j+1)>=num || arr[i][j+1] !=0){
    
68.                                 return 2;
    
69.                         }
    
70.                         else return 1;
    
71.                 }
    
72.                 //如果上一步向下走，则判断该位置下面位置是否已被访问或已达边界，是返回3，指示下一步向左走，否返回2继续下走。
    
73.                 else if(move == 2){
    
74.                         if((i+1)>=num || arr[i+1][j] != 0){
    
75.                                 return 3;
    
76.                         }
    
77.                         else return 2;
    
78.                 }
    
79.                 //如果上一步向左走，则判断该位置左侧位置是否已被访问或已达边界，是返回4，指示下一步向上走，否返回3继续左走。
    
80.                 else if(move == 3){
    
81.                         if(j<=0 || arr[i][j-1] != 0){
    
82.                                 return 4;
    
83.                         }
    
84.                         else return 3;
    
85.                 }
    
86.                 //如果上一步向上走，则判断该位置上面位置是否已被访问或已达边界，是返回1，指示下一步向右走，否返回4继续向上走。
    
87.                 else if(move == 4){
    
88.                         if(i<=0 || arr[i-1][j] != 0){
    
89.                                 return 1;
    
90.                         }
    
91.                         else return 4;
    
92.                 }
    
93.                 return -1;
    
94.                
    
95.         }
    
96. }
    

复制代码