写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
public class Test9 {

        /**
         * @param args
         */
        public static void main(String[] args) {
                System.out.println("请输入一个整数：");
                Scanner s = new Scanner(System.in);// 获取键盘存入
                int n = s.nextInt();// 读取一个int
                // System.out.println(n);
                int[][] array = new int[n][n];// 建立二维数组存入数据

                int count = 0;// 要循环次数
                if (n % 2 == 0)
                        count = n / 2;// 偶数时好
                else
                        count = n / 2 + 1;// 奇数时加1
                int data = 1;// 初始化数据
                // 循环开始填充数据
                for (int i = 0; i < count; i++) {

                        // 从左到右
                        for (int j = i; j < n - i; j++) {//选填满顶部行
                                array[i][j] = data++;

                        }
                        // 从上到下
                        for (int k = i + 1; k < n - i ; k++) {
                                array[k][n - i - 1] = data++;
                        }
                        // 从右到左
                        for (int x = n - i - 2; x > i; x--) {
                                array[n - i - 1][x] = data++;
                        }
                        // 从下到上
                        for (int y = n - i - 1; y > i; y--) {
                                array[y][i] = data++;
                        }

                }
                for (int i = 0; i < array.length; i++) {
                        for (int j = 0; j < array[i].length; j++) {
                                System.out.print(array[i][j] + "\t");
                        }
                        System.out.println();
                }

        }
}

学习了                        

入学考题好难啊。。。你用了多久做出来的？

我的思路是每填充一个数字就根据一定的规则判断下一步该往哪个方向走。这里的规则是先确定当前可以走的方向，然后按题目要求确定最终走向。“当前可以走的方向”通过是否触碰边界来判断。边界有2个，一是数组本身的边界，二是已经填充过的位置。核心代码如下：

1. public static void fill(int[][] square) {
   
2.             int dim = square.length;
   
3.             int num = 1, i = 0, j = 0;
   
4.             for (;num <= dim * dim; num++) {
   
5.                     square[i][j] = num;
   
6.                     boolean right = j < dim - 1 && square[i][j + 1] == 0;
   
7.                     boolean down = i < dim - 1 && square[i + 1][j] == 0;
   
8.                     boolean left = j > 0 && square[i][j - 1] == 0;
   
9.                     boolean up = i > 0 && square[i - 1][j] == 0;
   
10.                    
    
11.                    
    
12.                     if (right && down)
    
13.                             j++;
    
14.                     else if (down)
    
15.                             i++;
    
16.                     else if (left)
    
17.                             j--;
    
18.                     else if (up)
    
19.                             i--;
    
20.                     else if (right)
    
21.                             j++;
    
22.                    
    
23.             }
    
24.         }

复制代码

题目都有点看不懂。。收藏下

螺旋方阵?  大神呀

这种算法的题 很讨人厌！！！

顶一个。。。。

收藏一下！

用递归算法

这个要学习一下

最讨厌这种算法题了

学习了

我的做法，不知道效率怎么样

1. 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：   
   
2. *                 1   2   3   4
   
3. *                 12  13  14        5
   
4. *                 11        16  15        6
   
5. *                 10  9   8   7
   
6. *                 分析:
   
7. *                         1.等长的二维数组，new int[length][length]，最大索引为length-1.此处的length为题目中的n。
   
8. *                         2.图形中的数字是递增的，范围是 1 ~ length*length
   
9. *                         3.定义变量x记录二维数组的索引，y记录一维数组的索引。x控制索引的纵向移动，y控制索引的横向移动。
   
10. *                         4.图形是由多个闭合的数字组成的长方形组合起来的。用循环语句实现，定义计数器int count记录循环的次数,每次循环结束后+1.
    
11. *                         5.第一次的起点位置是arr[0][0],以后每次循环的起点为arr[count][count]
    
12. *                         6.向右移动, x不变, y++, 自增后赋值, 循环条件为x==count&&y<length-1-count
    
13. *                               向下移动, y不变，  x++, 自增后赋值, 循环条件为y==length-1-count&&x<length-1-count
    
14. *                               向左移动, x不变，  y--, 自减后赋值, 循环条件为x==length-1-count&&y>count
    
15. *                               向上移动, y不变，  x--, 自减后赋值, 循环条件为y==count&&x>count+1:每次循环的起点位置已经赋值，所以x>count+1
    
16. */
    
17. package com.itheima;
    
18. 
    
19. import java.util.Scanner;
    
20. 
    
21. /**
    
22. * 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
    
23. *          1   2   3   4
    
24. *                 12  13  14        5
    
25. *                 11        16  15        6
    
26. *                 10  9   8   7
    
27. *
    
28. * @author 面具
    
29. *
    
30. */
    
31. public class Test9 {
    
32.         public static void main(String[] args) {
    
33.                 System.out.println("请输入二维数组的长度，");
    
34.                 // 获取键盘录入的数字
    
35.                 @SuppressWarnings("resource")
    
36.                 Scanner sc = new Scanner(System.in);
    
37.                 int length = sc.nextInt();
    
38.                 // 定义二维数组，接收赋值后的等长二维数组
    
39.                 int[][] arr = method(length);
    
40.                 // 调用方法遍历二维数组
    
41.                 printArr(arr);
    
42.         }
    
43. 
    
44.         /**
    
45.          * @param arr
    
46.          *            接收一个需要遍历的二维数组
    
47.          */
    
48.         public static void printArr(int[][] arr) {
    
49.                 // 外层循环遍历二维数组中的一维数组
    
50.                 for (int x = 0; x < arr.length; x++) {
    
51.                         // 内循环遍历一维数组中的元素
    
52.                         for (int y = 0; y < arr[x].length; y++) {
    
53.                                 // 打印元素
    
54.                                 System.out.print(arr[x][y] + "\t");
    
55.                         }
    
56.                         System.out.println();
    
57.                 }
    
58. 
    
59.         }
    
60. 
    
61.         /**
    
62.          * @param length
    
63.          *            接收一个int型变量，该变量为二维数组的长度
    
64.          * @return 返回赋值后的二维数组
    
65.          */
    
66.         public static int[][] method(int length) {
    
67.                 // 定义一个等长二维数组
    
68.                 int[][] arr_1 = new int[length][length];
    
69.                 // 定义变量记录二维数组的中一位数组的值
    
70.                 int num = 1;
    
71.                 // 定义变量记录循环的次数
    
72.                 int count = 0;
    
73.                 // 循环语句，控制条件为num<=length*length
    
74.                 while (num <= (length * length)) {
    
75.                         // 定义变量记录二维数组的索引值
    
76.                         int i = count;
    
77.                         // 定义变量记录一维数组的索引值
    
78.                         int j = count;
    
79.                         // 给每次循环的起点赋值
    
80.                         arr_1[i][j] = num++;
    
81.                         // 向右移动,i不变, j++
    
82.                         while (i == count && j < length - 1 - count) {
    
83.                                 // 一维数组索引自增
    
84.                                 j++;
    
85.                                 arr_1[i][j] = num++;
    
86.                         }
    
87.                         // 向下移动,j不变,i++
    
88.                         while (j == length - 1 - count && i < length - 1 - count) {
    
89.                                 // 二维数组索引自增
    
90.                                 i++;
    
91.                                 arr_1[i][j] = num++;
    
92.                         }
    
93.                         // 向左移动,i不变,j--
    
94.                         while (i == length - 1 - count && j > count) {
    
95.                                 // 一维数组索引自减
    
96.                                 j--;
    
97.                                 arr_1[i][j] = num++;
    
98. 
    
99.                         }
    
100.                         // 向上移动,j不变,i--
     
101.                         while (j == count && i > count + 1) {
     
102.                                 // 二维数组索引自减
     
103.                                 i--;
     
104.                                 arr_1[i][j] = num++;
     
105.                         }
     
106.                         count++;
     
107.                 }
     
108. 
     
109.                 return arr_1;
     
110.         }
     
111. }
     

复制代码

算法什么的最讨厌了