写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。如： n = 4 则打印：

1	2	3	4
12	13	14	5
11	16	15	6
10	9	8	7

1. public class Test9 {
   
2.         static int cnt=0;
   
3.         static int[][] i = null;
   
4.         public static void main(String[] args) {
   
5.                 Scanner sc = new Scanner(System.in);
   
6.                 System.out.println("请输入要打印的等长二维数组长度");
   
7.                 int nextInt = sc.nextInt();
   
8.                 if (nextInt > 0) {
   
9.                         i=new int[nextInt][nextInt];
   
10.                         shuzu(i,0,nextInt);
    
11.                 } else {
    
12.                         System.out.println("请重新输入");
    
13.                 }
    
14.                 for (int k = 0; k < nextInt; k++) {
    
15.                         for (int j = 0; j < nextInt; j++) {
    
16.                                 System.out.print(i[k][j]+"\t");
    
17.                         }
    
18.                         System.out.println();
    
19.                 }
    
20.         }
    
21.         public static void shuzu(int[][] i, int start,int end) {
    
22.                 if(end-start==1)
    
23.                 {
    
24.                         i[start][end-1]=++cnt;
    
25.                         return;
    
26.                 }
    
27.                 if(start==end)
    
28.                         return;
    
29.                 for (int j = start; j < end-1; j++) {
    
30.                         i[start][j]=++cnt;
    
31.                 }
    
32.                 for (int j = start; j < end-1; j++) {
    
33.                         i[j][end-1]=++cnt;
    
34.                 }
    
35.                 for (int j = end-1; j >start; j--) {
    
36.                         i[end-1][j]=++cnt;
    
37.                 }
    
38.                 for (int j = end-1; j >start; j--) {
    
39.                         i[j][start]=++cnt;
    
40.                 }
    
41.                 shuzu(i,start+1,end-1);
    
42.         }
    
43. }

复制代码

试着做了做了一下，感觉挺有意思的！希望多批评指点!

目前基础还不够,看的迷迷糊糊的.我先回去学学基础去.

有注释更好了

看着晕晕

看看这个呗

我来个非递归版的。也不知道为什么，自己做题的话基本写不到递归上去……

1. package com.itheima;
   
2. 
   
3. /**
   
4. * 9.写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
   
5. * 如： n = 4 则打印：
   
6. * 1     2     3     4
   
7. * 12    13    14    5
   
8. * 11    16    15    6
   
9. * 10    9     8     7
   
10. * 分析：
    
11. * （1）整个螺旋可以分为多个圈。可以算出这个圈数，从外到里分别为第0,1,2，……圈；
    
12. * （2）每圈螺旋可以拆分为首尾相接的上端、右端、下端、左端四条线路；
    
13. * （3）因此大致框架是两层循环，外层循环是螺旋圈数，内层循环由4个串联的循环组成，分别表示四条线路。
    
14. * @author Administrator
    
15. *
    
16. */
    
17. public class Test9 {
    
18. 
    
19.         // 在主函数中定义要打印长度为多少的螺旋排列数组并调用打印方法
    
20.         public static void main(String[] args) {
    
21.                 int n = 9;
    
22.                 showHelixArray(n);
    
23.         }
    
24. 
    
25.         // 打印螺旋排列数组的方法，形参为二维数组的长度
    
26.         public static void showHelixArray(int size) {
    
27.                 // 创建二维数组
    
28.                 int[][] arr = new int[size][size];
    
29.                 // 计算螺旋圈数
    
30.                 int circlecount = (size % 2 == 0 ? size / 2 : size / 2 + 1);
    
31.                
    
32.                 // 获取每一圈有多少个数字，并存放在一个数组中
    
33.                 int[] numbercounts = new int[circlecount];
    
34.                 for (int i = 0; i < circlecount; i++) {
    
35.                         int numbercount;
    
36.                         if (i != circlecount - 1) {
    
37.                                 numbercount = (size - 1 - 2 * i) * 4;
    
38.                         } else {
    
39.                                 numbercount = (size % 2 == 0 ? (size - 1 - 2 * i) * 4 : 1);
    
40.                         }
    
41.                         numbercounts[i] = numbercount;
    
42.                 }
    
43. 
    
44.                 // 获取每一圈数字的起始索引，并存放在一个数组中
    
45.                 int[] index = new int[circlecount];
    
46.                 for (int i = 0; i < circlecount; i++) {
    
47.                         int startindex = 1;
    
48.                         for (int j = 0; j < i; j++) {
    
49.                                 startindex = startindex + numbercounts[j];
    
50.                         }
    
51.                         index[i] = startindex;
    
52.                 }
    
53. 
    
54.                 // 向二维数组中按螺旋顺序添加数字
    
55.                 for (int i = 0; i < circlecount; i++) {
    
56.                         // 获取这一圈的数字起始索引
    
57.                         int startindex = index[i];
    
58.                         // 定义从起始索引开始的指针，通过指针向数组中添加数字
    
59.                         int pointer = startindex;
    
60.                         // 获取上下左右四条添加线路的位置极限（右边界或下边界）
    
61.                         int limit = (numbercounts[i] == 1 ? 1 : numbercounts[i] / 4) + i;
    
62.                         // 向上端线路中添加数字
    
63.                         for (int j = i; j < limit; j++) {
    
64.                                 arr[i][j] = pointer++;
    
65.                         }
    
66.                         // 如果最后一圈只有一个数字，则只需要走上端线路，其他情况需要四条线路依次走一遍
    
67.                         if (numbercounts[i] != 1) {
    
68.                                 // 向右端线路中添加数字
    
69.                                 for (int j = i; j < limit; j++) {
    
70.                                         arr[j][limit] = pointer++;
    
71.                                 }
    
72.                                 // 向下端线路中添加数字（反向）
    
73.                                 for (int j = limit - 1; j >= i; j--) {
    
74.                                         arr[limit][j + 1] = pointer++;
    
75.                                 }
    
76.                                 // 向左端线路中添加数字（反向）
    
77.                                 for (int j = limit - 1; j >= i; j--) {
    
78.                                         arr[j + 1][i] = pointer++;
    
79.                                 }
    
80.                         }
    
81.                 }
    
82.                
    
83.                 // 添加完毕后，打印二维数组
    
84.                 for (int i = 0; i < size; i++) {
    
85.                         for (int j = 0; j < size; j++) {
    
86.                                 System.out.print(arr[i][j] + "\t");
    
87.                         }
    
88.                         System.out.println();
    
89.                 }
    
90.         }
    
91. }

复制代码

学习了,谢谢分享