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


代码：

1. package com.java;
   
2. 
   
3. public class PrintFangZhen {
   
4. 
   
5.         /**
   
6.          * 打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
   
7.          * 1 2 3 4
   
8.          * 12 13 14 5
   
9.          * 11 16 15 6
   
10.          * 10 9 8 7
    
11.          *
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 int n = 4;
    
15.                 if (n <= 0) {
    
16.                         System.out.println("n必须大于0！");
    
17.                         return;
    
18.                 }
    
19.                 int[][] arr = method(n);
    
20.                 traverse(arr);
    
21.         }
    
22. 
    
23.         /**
    
24.          * 按从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列，并存到一个二维数组中
    
25.          *
    
26.          * @param n
    
27.          *            这个方阵的边长
    
28.          * @return 一个二维数组
    
29.          */
    
30.         public static int[][] method(int n) {
    
31.                 // 定义一个储存数字的二维数组
    
32.                 int[][] arr = new int[n][n];
    
33.                 // 定义一个count计数，count即为数组中的元素
    
34.                 int count = 0;
    
35.                 int i = 0, j = 0;
    
36.                 while (true) {
    
37.                         // 当n为1的时候，直接存入数组中并结束循环
    
38.                         if (n == 1) {
    
39.                                 arr[0][0] = 1;
    
40.                                 break;
    
41.                         }
    
42.                         // 当一个元素的上、右、下、左的值不是0的时候；或者是当其上和右有值，并且左和下越界时，结束循环
    
43.                         if ((i - 1 >= 0 && j + 1 <= n - 1 && i + 1 <= n - 1 && j - 1 >= 0
    
44.                                         && arr[i - 1][j] != 0 && arr[i][j + 1] != 0
    
45.                                         && arr[i + 1][j] != 0 && arr[i][j - 1] != 0)
    
46.                                         || (j - 1 < 0 && i + 1 > n - 1 && arr[i - 1][j] != 0 && arr[i][j + 1] != 0)) {
    
47.                                 break;
    
48.                         }
    
49.                         // 如果上面的角标越界了，并且右面的角标没越界，则向右移动
    
50.                         if ((i - 1 < 0 && j <= n - 1)) {
    
51.                                 arr[i][j++] = ++count;
    
52.                         } else if (j + 1 > n - 1 && i + 1 <= n - 1) {
    
53.                                 // 如果右面的角标越界了，并且下面的角标没越界，则向下移动
    
54.                                 if (j == n) {
    
55.                                         j--;
    
56.                                 }
    
57.                                 i++;
    
58.                                 arr[i][j] = ++count;
    
59.                         } else if (i + 1 > n - 1 && j - 1 >= 0) {
    
60.                                 // 如果下面的角标越界了，并且左边的角标没越界，则向左移动
    
61.                                 arr[i][--j] = ++count;
    
62.                         } else if (j - 1 < 0 && i - 1 >= 0 && arr[i - 1][j] == 0) {
    
63.                                 // 如果左边的角标越界了，并且上边的角标没越界，并且上边的元素的值为0，则向上移动
    
64.                                 arr[--i][j] = ++count;
    
65.                         } else {
    
66.                                 // 如果不是边缘，则按其他情况来计算
    
67.                                 if (arr[i - 1][j] != 0 && arr[i][j + 1] == 0) {
    
68.                                         // 如果右面元素的值为0，并且上面元素的值不为0，则向右移动
    
69.                                         arr[i][++j] = ++count;
    
70.                                 } else if (arr[i + 1][j] == 0) {
    
71.                                         // 如果下面元素的值为0，则向下移动
    
72.                                         arr[++i][j] = ++count;
    
73.                                 } else if (arr[i][j - 1] == 0) {
    
74.                                         // 如果左面元素的值为0，则向左移动
    
75.                                         arr[i][--j] = ++count;
    
76.                                 } else if (arr[i - 1][j] == 0) {
    
77.                                         // 如果上面元素的值为0，则向上移动
    
78.                                         arr[--i][j] = ++count;
    
79.                                 }
    
80.                         }
    
81. 
    
82.                 }
    
83.                 return arr;
    
84.         }
    
85. 
    
86.         /**
    
87.          * 遍历二维数组
    
88.          *
    
89.          * @param arr
    
90.          *            一个待遍历的二维数组
    
91.          */
    
92.         public static void traverse(int[][] arr) {
    
93.                 for (int i = 0; i < arr.length; i++) {
    
94.                         for (int j = 0; j < arr[i].length; j++) {
    
95.                                 System.out.print(arr[i][j] + " ");
    
96.                         }
    
97.                         System.out.println();
    
98.                 }
    
99.         }
    
100. 
     
101. }
     

复制代码

如果大家还有更好的方法，欢迎交流。

就是蜗牛呗，记得以前用C语言写，当时还没做出来

我表示完全看不懂是什么意思

好复杂啊  

这是入学考试题吧

学习下啊...

试着写了下。

1. package test;
   
2. 
   
3. public class Test8 {
   
4.     private final static int RIGHT = 0, DOWN = 1, LEFT = 2, UP = 3;// 定义方向常量
   
5. 
   
6.     public static void main(String[] args) {
   
7.         printArray(10);
   
8.     }
   
9. 
   
10.     public static void printArray(int length) {
    
11.         int direction = RIGHT;// 移动方向
    
12.         int[][] array = new int[length][length];// 注意，整形数组元素默认值是0，值为0即未被填充
    
13.         // row、col为将要填充数据的行号和列号
    
14.         for (int i = 1, row = 0, col = 0; i <= length * length; i++) {
    
15.             array[row][col] = i;
    
16.             // 根据方向，确定下一个填充数据的坐标的位置
    
17.             switch (direction) {
    
18.             case RIGHT:
    
19.                 // 当右边不越界，且右边位置的值为0时，指针向右移动
    
20.                 if (col + 1 < length && array[row][col + 1] == 0) {
    
21.                     col++;// 列号增加表示指针右移
    
22.                 } else {// 否则更改方向，向下移动
    
23.                     direction = DOWN;
    
24.                     row++;// 行好增加表示向下移动
    
25.                 }
    
26.                 break;
    
27.             case DOWN:// 其他方向类似，右→下,下→左，左→上，上→右
    
28.                 if (row + 1 < length && array[row + 1][col] == 0) {
    
29.                     row++;
    
30.                 } else {
    
31.                     direction = LEFT;
    
32.                     col--;
    
33.                 }
    
34.                 break;
    
35.             case LEFT:
    
36.                 if (col - 1 > -1 && array[row][col - 1] == 0) {
    
37.                     col--;
    
38.                 } else {
    
39.                     direction = UP;
    
40.                     row--;
    
41.                 }
    
42.                 break;
    
43.             case UP:
    
44.                 if (row - 1 > -1 && array[row - 1][col] == 0) {
    
45.                     row--;
    
46.                 } else {
    
47.                     direction = RIGHT;
    
48.                     col++;
    
49.                 }
    
50.                 break;
    
51.             }
    
52.         }
    
53.         print(array);// 打印数组
    
54.     }
    
55. 
    
56.     private static void print(int[][] array) {
    
57.         for (int i = 0; i < array.length; i++) {
    
58.             for (int j = 0; j < array[i].length; j++) {
    
59.                 System.out.print(array[i][j] + "\t");
    
60.             }
    
61.             System.out.println();
    
62. 
    
63.         }
    
64. 
    
65.     }
    
66. }
    
67. 
    

复制代码

我也有这个题,这是我的做法,略显麻烦!:L

1. package com.itheima;
   
2. 
   
3. /**
   
4. * 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
   
5. * 1        2        3        4
   
6. * 12        13        14        5
   
7. * 11        16        15        6
   
8. * 10         9        8         7
   
9. *
   
10. *思路:
    
11. *1.定义一个二维数组,请arr用来接收要打印的数据
    
12. *2.打印该螺旋方式,可以将螺旋看成是多次循环,每次循环的开始位置都是a[0][0]  a[1][1] a[2][2]...
    
13. *3.只需根据给定的n的值确定循环次数即可,循环次数为(n+1)/2
    
14. *4.另外需要确定每次开始位置的值,随后按照螺旋顺序让对应角标值递增即可
    
15. *5.遍历数组并按要求打印
    
16. *
    
17. *
    
18. */
    
19. public class Test9 {
    
20. 
    
21.         public static void main(String[] args) {
    
22.                
    
23.                 //定义变量n用来表示需要打印的数组的大小
    
24.                 int n = 15;
    
25.                
    
26.                 //定义print()方法,用来完成数组内容的确定并打印
    
27.                 print(n);
    
28.         }
    
29. 
    
30.         public static void print(int n) {
    
31.                
    
32.                 //定义一个int型数组,用来接收需要打印的数据
    
33.                 int[][] arr = new int[n][n];
    
34.                
    
35.                 //定义int型变量count,用来表示螺旋数组循环的次数
    
36.                 int count = (n + 1) / 2;
    
37.                
    
38.                 //确定每个循环开始出的初始值a[0][0] a[1][1] a[2][2]...
    
39.                 arr[0][0] = 1;
    
40.                 for (int i = 1; i < count; i++) {
    
41.                         arr[i][i] = arr[i - 1][i - 1] + ((n - (i - 1) * 2) * 2 - 2) * 2;
    
42.                 }
    
43.                
    
44.                 //使用for循环,依次循环确定每次回环上的对应角标的值
    
45.                 for (int i = 0; i < count; i++) {
    
46.                        
    
47.                         //该循环用于确定每次回环上上边缘数据
    
48.                         for (int j = i + 1; j < arr.length - i; j++) {
    
49.                                 arr[i][j] = arr[i][j - 1] + 1;
    
50.                         }
    
51.                        
    
52.                         //该循环用于确定每次回环上右边缘的数据
    
53.                         for (int j = i + 1; j < arr.length - i; j++) {
    
54. 
    
55.                                 arr[j][arr.length - i - 1] = arr[j - 1][arr.length - i - 1] + 1;
    
56.                         }
    
57.                        
    
58.                         //该循环用于确定每次回环上下边缘的数据
    
59.                         for (int j = arr.length - i - 2; j >= 0 + i; j--) {
    
60.                                 arr[arr.length - i - 1][j] = arr[arr.length - i - 1][j + 1] + 1;
    
61. 
    
62.                         }
    
63.                        
    
64.                         //该循环用于确定每次回环上左边缘的数据
    
65.                         for (int j = arr.length - i - 2; j > 0 + i; j--) {
    
66.                                 arr[j][i] = arr[j + 1][i] + 1;
    
67.                         }
    
68. 
    
69.                 }
    
70.                
    
71.                 //使用for循环获得一维数组
    
72.                 for (int i = 0; i < arr.length; i++) {
    
73.                         int[] js = arr[i];
    
74.                        
    
75.                         //使用for循环获取每个一维数组中的元素,并按要求打印
    
76.                         for (int j = 0; j < js.length; j++) {
    
77.                                 System.out.print(js[j] + "\t");
    
78. 
    
79.                         }
    
80.                         //每次打印完成一个一维数据后进行换行
    
81.                         System.out.println();
    
82. 
    
83.                 }
    
84.         }
    
85. }
    

复制代码

顶一下！！！

Bukeng 发表于 2014-7-13 18:26
这是入学考试题吧

是的。:)