本人写的正方形代码如下：

1. package cn.itheima.exam;
   
2. /**
   
3. * 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：     
   
4. *        1        2        3        4
   
5. *        12        13        14        5
   
6. *        11        16        15        6
   
7. *        10        9        8        7
   
8. */
   
9. public class Test9 {
   
10. 
    
11.         public static void main(String[] args) {
    
12.                 int[][] arr=new int[9][9];
    
13.                 circleArr(arr);
    
14.                 for(int x=0;x<arr.length;x++)
    
15.                 {
    
16.                         for(int y=0;y<arr[0].length;y++)
    
17.                         {
    
18.                                 System.out.print(arr[x][y]+"  \t  ");
    
19.                                
    
20.                         }
    
21.                         System.out.println();
    
22.                 }
    
23.        
    
24.         }
    
25. 
    
26.         private static void circleArr(int[][] arr) {
    
27.                 int x=0,y=0;
    
28.                 int max=arr.length-1;
    
29.                 int min=0;
    
30.                 int z=0;
    
31.                 for(;max>=min;){
    
32.                
    
33.                         for(;y<max;y++){       
    
34.                                 z++;
    
35.                         arr[x][y]=z;
    
36.                         }
    
37.                        
    
38.                         for(;x<max;x++)
    
39.                         {        z++;
    
40.                                 arr[x][y]=z;
    
41.                         }
    
42.                        
    
43.                         for(;y>min;y--)
    
44.                         {        z++;
    
45.                                 arr[x][y]=z;
    
46.                         }
    
47.                         for(;x>min;x--)
    
48.                         {
    
49.                                 z++;
    
50.                                 arr[x][y]=z;
    
51.                         }
    
52.                         if(max==min)
    
53.                         {
    
54.                                 arr[x][y]=++z;
    
55.                         }
    
56.                         x++;
    
57.                         y++;
    
58.                         max--;
    
59.                         min++;
    
60.                 }
    
61.         }
    
62. 
    
63. }

复制代码

用类似树的深度搜索，走完一步，去搜索可走的下一步。注释很详细，不详解了。

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

复制代码