package com.itheima;
/*9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印
*
* 1   2  3  4
* 12  13 14 5
* 11  16 15 6
* 10        9 8  7
*
* */
public class Test9 {
    public static void main(String[] args){
            arrayNum(4);
    }

//便于改代码..输入不同y值输出不同的二维数列
    private static void arrayNum(int y)
    {
            int[][] arr=new int[y][y];
            int n=arr.length;
            int max=0;
            int c=0;
            specArr(arr,n,max,c);
            arrPrint(arr);
    }

   //高级for输出打印用的
    private static void arrPrint(int[][] h) {
            for(int[] in:h)
            {
                    for(int t:in)
                    {        
                            if(t<10)System.out.print(" "+t+" ");
                            else System.out.print(t+" ");
                    }
                    System.out.println();
            }
            
    }
   
//利用递归,一层一层写进去..
    private static void specArr(int[][] arr,int n,int max,int count) {
            
            if(n>0){
            int j=0;
            for(int i=0;i<(n-1)*4;i++)
            {
                    if (i<n-1)  arr[0+count][i+count]=++max;
                    else if (i<2*n-2) arr[count+j++][arr.length-1-count]=++max;
                    else if (i<3*n-3) arr[arr.length-1-count][(j--)+count]=++max;
                    else if (i<4*n-4) arr[arr.length-1-(j++)-count][0+count]=++max;                        
            }        
            if(n==1){arr[arr.length/2][arr.length/2]=max+1 ;}//注意到 当y值为奇数时,会有循环到n=1的情况,需要补进数组最中间值
            count++;
            n-=2;
            specArr(arr,n,max,count);
            }
    }

}  

楼主 我这里有个简单的  也有注释

1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /**
   
6. * 需求: 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
   
7.         1  2  3  4
   
8.         12 13 14 5
   
9.         11 16 15 6
   
10.         10  8  9 7
    
11.        
    
12.         @author 刘阳文
    
13. * */
    
14. public class Test9
    
15. {
    
16.         public static void main(String[] args)
    
17.         {
    
18.                 Scanner input = null; //键盘录入
    
19. 
    
20.                 try
    
21.                 {
    
22.                         input = new Scanner(System.in);
    
23.                         System.out.println("请输入数字:");
    
24.                         // 要打印的长度
    
25.                         int count = input.nextInt();
    
26. 
    
27.                         // 声明等长的二维数组
    
28.                         int[][] arr = new int[count][count];
    
29. 
    
30.                         // 生成螺旋数组
    
31.                         genericArray(arr, (count * count));
    
32. 
    
33.                         // 打印结果到控制台
    
34.                         System.out.println("生成的螺旋数组如下:");
    
35.                         print(arr, count);
    
36. 
    
37.                 } catch (Exception e)
    
38.                 {
    
39.                         System.out.println("输入非法,请输入数字");
    
40.                 } finally
    
41.                 {
    
42.                         try
    
43.                         {
    
44.                                 if (input != null)
    
45.                                         input.close();
    
46.                         } catch (Exception e2)
    
47.                         {
    
48.                                 System.out.println("关闭流失败");
    
49.                         }
    
50.                 }
    
51. 
    
52.         }
    
53. 
    
54.         // 生成螺旋数组
    
55.         private static void genericArray(int[][] arr, int value)
    
56.         {
    
57.                 int n = 1;// 初始数值
    
58. 
    
59.                 // (arr.length+1)/2是圈数
    
60.                 for (int i = 0; i < (arr.length + 1) / 2; i++)
    
61.                 {
    
62.                         int index = arr.length - i - 1;
    
63.                         // 大圈套小圈
    
64.                         if (quan(arr, i, index, n, value) != null)
    
65.                                 n = quan(arr, i, index, n, value);
    
66.                 }
    
67. 
    
68.         }
    
69. 
    
70.         // 跑圈
    
71.         private static Integer quan(int[][] arr, int i, int index, int n, int value)
    
72.         {
    
73.                 // 左 ---> 右
    
74.                 for (int j = i; j < index + 1; j++)
    
75.                 {
    
76.                         arr[i][j] = n++;
    
77.                         if (n == value)// 数组数值已满,结束本功能
    
78.                                 return null;
    
79.                 }
    
80.                 // 上 ---> 下 最上面一个去除
    
81.                 for (int j = i + 1; j < index + 1; j++)
    
82.                 {
    
83.                         arr[j][index] = n++;
    
84.                 }
    
85.                 // 右 ---> 左 最右边一个去除
    
86.                 for (int j = index - 1; j >= i; j--)
    
87.                 {
    
88.                         arr[index][j] = n++;
    
89.                 }
    
90.                 // 下 ---> 上 去除最上面一个和最下面一个
    
91.                 for (int j = index - 1; j > i; j--)
    
92.                 {
    
93.                         arr[j][i] = n++;
    
94.                 }
    
95.                 return n;
    
96.         }
    
97. 
    
98.         // 打印二维数组
    
99.         private static void print(int[][] arr, int n)
    
100.         {
     
101.                 for (int i = 0; i < arr.length; i++)
     
102.                 {
     
103.                         for (int j = 0; j < arr[i].length; j++)
     
104.                         {
     
105.                                 if (j % n == 0)
     
106.                                         System.out.println();
     
107.                                 System.out.print(arr[i][j] + "\t");
     
108. 
     
109.                         }
     
110.                 }
     
111.         }
     
112. }
     

复制代码

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

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. }
    

复制代码

你不要急，只要你发帖，回答，版主都会给你加分的。。

ehuashao 发表于 2014-5-1 08:43
有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

这个思路是极好的:victory:

赞一个 顶顶顶！！！！

ehuashao 发表于 2014-5-1 08:43
有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

真的是学习了 你真是大神  

ehuashao 发表于 2014-5-1 08:43
有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

你这思路真心挺好的

没有精简一些的吗

这么多方法！

发现自己好菜啊:'(

谢谢分享

学习了，谢谢分享

都是大神啊。666666666666

ehuashao 发表于 2014-5-1 08:43
有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

思路清晰,写的非常棒~~

ehuashao 发表于 2014-5-1 08:43
有详细注释，用树的深度搜索想法实现。本人原创，转载请注明。

赞，这是最适合新手理解得思路了

还是没看懂 啊

值得学习。。。。

学习~学习！学习。学习。

非常给力。完美解决了我的笔试题目