一道入学测试题，写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 5则打印：  1   2   3   4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9
实在想不出来怎么做，看看别人的代码，有一个地方不懂。不懂的地方在代码注释上，希望各位大师给解答一下

1. public class java {
   
2.         public static void main(String[] args) {  
   
3.         //调用打印从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列的二维数组方法  
   
4.         arrPrint(5);  
   
5.     }  
   
6.     //打印从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列的二维数组  
   
7.     public static void arrPrint(int num){  
   
8.         //定义定长二维数组  
   
9.         int[][] arr = new int[num][num];  
   
10.         int n = arr.length;  
    
11.         int count = 0;  
    
12.         int max = 0;  
    
13.         //递归为二维数组赋值  
    
14.         rec2DArr(arr,n,count,max);  
    
15.         //打印  
    
16.         print2DArr(arr);  
    
17.     }  
    
18.     public static void rec2DArr(int[][] arr,int n,int count,int max){  
    
19.         //递归控制条件  
    
20.         if(n>0){  
    
21.             //纵坐标控制值  
    
22.             int k = 0;  
    
23.             //(n-1)*4代表每一圈的数值范围  
    
24.             for(int i=0;i<(n-1)*4;i++){  
    
25.                 //在上边赋值  
    
26.                 if(i<n-1){  
    
27.                     arr[count+0][count+i] = ++max;  
    
28.                 }  
    
29.                 //向右边赋值  
    
30.                 else if(i<2*n-2){  
    
31.                     arr[count+k++][arr.length-1-count]=++max;  
    
32.                 }  
    
33.                 //在下边赋值   
    
34.                 else if(i<3*n-3){     <font color="#ff0000">//当n=8时，数组是arr[5-1-0][3+0]??????实际应该是arr[3][4]啊，对于8这个临界值，就应该在这个if语句中啊？？？？？</font>

复制代码

这个题我没有做出来，原来要用二维数组。学习

这个其实就是看你滴问题的思考，首先，实现巧妙利用变量来对二位数组进行控制，
     public static void main(String args[])  
  
String strIn="";  
System.out.println("请输入矩阵的行列数：");  
InputStreamReader input=new InputStreamReader(System.in);  
BufferedReader buff=new BufferedReader(input);  
try  
{  
    strIn=buff.readLine();  
}  
catch (IOException ex)  
{  
    System.out.println(ex.toString());  
}  
  
int istr=Integer.parseInt(strIn);  
int n=istr;  
//System.out.println("这是行列数为："+ n +"螺旋矩阵”);  
int iInit=1;  
int array[][]=new int[n][n];  
int iCondition;  
if(n%2>0)  
{  
    iCondition=n/2+1;  
}  
else  
{  
    iCondition=n/2;  
}  
for(int i=0;i<iCondition;i++)  
{  
    for(int j=i;j<n-i;j++)  
    {  
        array[i][j]=iInit;  
        iInit++;  
    }  
    for(int k=i+1;k<n-i;k++)  
    {  
        array[k][n-i-1]=iInit;  
        iInit++;  
    }  
    for(int l=n-i-2;l>=i;l--)  
    {  
        array[n-i-1][l]=iInit;  
        iInit++;  
    }  
    for(int t=n-i-2;t>i;t--)  
    {  
        array[t][i]=iInit;  
        iInit++;  
    }  
  
    for(int m=0;m<n;m++)  
    {  
        for(int j=0;j<n;j++)  
        {  
            System.out.print(array[m][j]+"   ");  
        }  
        System.out.println();  
    }  
}

学习学习，很不错，希望我能很快的到达这一步

学习学习，不错

http://bbs.itheima.com/forum.php?mod=viewthread&tid=158259

不系之舟王 发表于 2014-12-31 09:35
恩恩，多谢哥们，确实看错了

客气啥，谁都有这样的经历！加油！

l763631191 发表于 2014-12-31 03:42
好难我不会！

我也不会。。。。

l763631191 发表于 2014-12-31 03:42
好难我不会！

我也不会。。。。

李增宽 发表于 2014-12-30 23:42
好乱。。。。

没怎么在论坛发过贴，代码有点乱了。。。。

寻觅 发表于 2014-12-30 17:53
你看差了，哥们！i是从0开始的，i是8的时候，数组是arr[4][4]==9,而你说的arr[3][4]==8,对应的i是7
...

恩恩，多谢哥们，确实看错了

王者之风西昆仑 发表于 2014-12-30 12:47
好难啊，不会做

:handshake

MengDeKaiShi 发表于 2014-12-30 10:42
确实似乎挺不容易想的

是啊，好多题我都看不懂让干嘛的，瞬间感觉没编程头脑啊。。。。

好难我不会！

好乱。。。。

你看差了，哥们！i是从0开始的，i是8的时候，数组是arr[4][4]==9,而你说的arr[3][4]==8,对应的i是7

好难啊，不会做

不想看代码了，直接把我的代码贴上吧，注解挺详细的

1. public class Test9 {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 Scanner input = new Scanner(System.in);
   
6.                 System.out.println("请输入一个整数: ");
   
7.                 //从键盘接收一个整数
   
8.                 int n = input.nextInt();
   
9. 
   
10.                 int[][] out = test(n);
    
11.                
    
12.                 //以矩形方式打印数组
    
13.                 for (int i = 0; i < n; i++) {
    
14.                         for (int j = 0; j < n; j++) {
    
15.                                 //每列数据间隔一个制表符
    
16.                                 System.out.print(out[i][j] + "\t");
    
17.                         }
    
18.                         //换行
    
19.                         System.out.print("\r\n");
    
20.                 }
    
21. 
    
22.                 input.close();
    
23.         }
    
24. 
    
25.         /**
    
26.          * 总思路：将二维数组看成一个正方形，先给二维数组上边和右边赋值，再给下边和左边赋值，通过标签flag控制两次赋值的循环
    
27.          *
    
28.          * @param n
    
29.          * @return
    
30.          */
    
31.         static int[][] test(int n) {
    
32.                 int[][] out = new int[n][n];
    
33. 
    
34.                 // 定义第一个数
    
35.                 int num = 1;
    
36. 
    
37.                 // 每次画的行和列的数据的个数，即键盘录入的整数
    
38.                 int m = n;
    
39. 
    
40.                 // 每次要赋值的行和列
    
41.                 int a = 0, b = -1;
    
42.                 /**
    
43.                  * flag为true就给上边和右边两边赋值， flag为false就给下边和左边两边赋值
    
44.                  * */
    
45.                 boolean flag = true;
    
46. 
    
47.                 // 结束的标记是行和列上的数据个数为0
    
48.                 while (m != 0) {
    
49.                         for (int i = 0; i < m; i++) {
    
50.                                 if (flag) {
    
51.                                         //给上边赋值
    
52.                                         out[a][++b] = num++;
    
53.                                 } else {
    
54.                                         //给下边赋值
    
55.                                         out[a][--b] = num++;
    
56.                                 }
    
57.                         }
    
58.                        
    
59.                         //为第二边赋值时由于两条边在拐角处有重合，所以赋值个数为m - 1
    
60.                         for (int i = 0; i < m - 1; i++) {
    
61.                                 if (flag) {
    
62.                                         // 给右边赋值
    
63.                                         out[++a][b] = num++;
    
64.                                 } else {
    
65.                                         //给左边赋值
    
66.                                         out[--a][b] = num++;
    
67.                                 }
    
68.                         }
    
69.                         // 每画完半圈下一次行数和列数上要画的数据数个数减1
    
70.                         m--;
    
71.                         // 翻转标签
    
72.                         flag = !flag;
    
73.                 }
    
74.                 return out;
    
75.         }
    
76. }

复制代码

确实似乎挺不容易想的

是当i的值为8时，也就是在下面这个语句里面

1. //在下边赋值  
   
2.                 else if(i<3*n-3){  
   
3.                     arr[arr.length-1-count][(k--)+count]=++max;  
   
4.                 }  

复制代码