/**
*         写一方法，打印等长的二维数组，要求从1开始的自然数由方陈的最外圈向内螺旋方式地顺序排列。
        如： n = 4 则打印：
               1             2          3          4
                12        13        14        5
                11        16        15        6
                10         9           8           7
*/
public class Test7 {


         public static void main(String[] args) {

                  int number = 4;

                  int[][] arys = printCircle(number);

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

                   System.out.println();
                  }
                 }


                 private static int[][] printCircle(int number) {

                  int[][] ary = new int[number][number];

                  int rightLen;
                  int downLen;
                  int leftLen;
                  int upLen;
                  
                  int rightRow = 0;
                  int rightCol = 0;
                  int leftRow = number - 1;
                  int leftCol = number - 1;
                  int downRow = 1;
                  int downCol = number - 1;
                  int upRow = number - 2;
                  int upCol = 0;

                  int digit = 1;
                  
                  while(number > 0){
                  
                   rightLen = number;
                   downLen = number - 1;
                   leftLen = number - 1;
                   upLen = number - 2;
                  
                   //Step 1: print to right
                   for(int i = 0, temp = rightCol; i < rightLen; i++){
                    ary[rightRow][temp++] = digit++;
                   }
                  
                   //Step 2: print to down
                   for(int j = 0, temp = downRow; j < downLen; j++){
                    ary[temp++][downCol] = digit++;
                   }
                  
                   //move left
                   for(int m = 0, temp = leftCol - 1; m < leftLen; m++){
                    ary[leftRow][temp--] = digit++;
                   }
                  
                   //move up
                   for(int n = 0, temp = upRow; n < upLen; n++){
                    ary[temp--][upCol] = digit++;
                   }
                  
                   number = number - 2;
                  
                   //increas/decrease the row and column
                   rightRow++;
                   rightCol++;
                   downRow++;
                   downCol--;
                   leftRow--;
                   leftCol--;
                   upRow--;
                   upCol++;
                  
                  }
                  
                  return ary;
                  
                 }

}
跪求高手，详解代码，写上注释，越详细越好。。。。
彻底迷糊。。。{:soso_e149:}

public class Test7 {
         public static void main(String[] args) {

         int number = 4;

         int[][] arys = printCircle(number);

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

          System.out.println();
         }
        }


        private static int[][] printCircle(int number) {
         //定义一个二维数组
         int[][] ary = new int[number][number];
         //长度
         int rightLen;//右边
         int downLen;//下边
         int leftLen;//左边
         int upLen;//上边
         
         int rightRow = 0;
         int rightCol = 0;
         int leftRow = number - 1;//3
         int leftCol = number - 1;//3
         int downRow = 1;
         int downCol = number - 1;//3
         int upRow = number - 2;//2
         int upCol = 0;

         int digit = 1;
         
         while(number > 0){
         
          rightLen = number;
          downLen = number - 1;//3
          leftLen = number - 1;//3
          upLen = number - 2;//2
         
          //Step 1: print to right
          //从右向左开始打印：
          //首先打印第一行for(int i=0,temp =0,i<4;i++)
          //rightCol右向行号
          for(int i = 0, temp = rightCol; i < rightLen; i++){
           ary[rightRow][temp++] = digit++;
          }
         
          //Step 2: print to down
         // for(j=0;temp=1;j<3;j++)
          //downCol打印最右边的那一列,从上往下
          for(int j = 0, temp = downRow; j < downLen; j++){
           ary[temp++][downCol] = digit++;
          }
         
          //move left
          //for(int m=0,temp=2;m<3;m++)
          //最底层，倒数第二列开始向左打印
          for(int m = 0, temp = leftCol - 1; m < leftLen; m++){
           ary[leftRow][temp--] = digit++;
          }
         
          //move up
          //for(int n =0,temp = 2;n<2;n++)
         // 打印第一列，从下往上开始
          for(int n = 0, temp = upRow; n < upLen; n++){
           ary[temp--][upCol] = digit++;
          }
         //答应一圈以后行和列都减少2，正方形缩小两行两列
          number = number - 2;
         
          //increas/decrease the row and column
          //变量变化
          rightRow++;
          rightCol++;
          downRow++;
          downCol--;
          leftRow--;
          leftCol--;
          upRow--;
          upCol++;
         
         }
         
         return ary;
         
        }


}

啸傲江湖007 发表于 2012-7-11 21:22
public class Test7 {
         public static void main(String[] args) {

说的不清楚啊，   详细点，清楚点

1. 00 01 02 03 04   
   
2. 10 11 12 13 14
   
3. 20 21 22 23 24
   
4. 30 31 32 33 34
   
5. 40 41 42 43 44
   
6. 以n=5为例子  上图表示数组元素的角标  根据题目我们要按照顺序给元素赋值 并不断自增  根据这个规律一圈一圈来
   
7. n为奇数时 就是n/2圈 加上中间一个    n为偶数就是n/2圈
   
8. 00 01 02 03 04
   
9. 10             14
   
10. 20             24
    
11. 30             34
    
12. 40 41 42 43 44
    
13. 
    
14. 11 12 13
    
15. 21     23
    
16. 31 32 33
    
17. 
    
18.      22
    
19. 这样外面的大循环 条件就确定了 打n/2个矩形
    
20. 这个描述以n=5为例
    
21. for(i=0;i<n/2,i++){
    
22. 然后每个矩形都有4条边，这样就需要4个for循环分别打印四条边
    
23. for(j=i;j<n-i;j++){  上面那条边 00 01 02 03 04   可以看出 左角标是不变的  右角标是递增的  那就需要循环的变量要递增  
    
24.     if(arr[i][j]==0)      第一大圈有5个元素 (j=i(0);j<n(5)-i(0);j++)   第二大圈有3个元素 (j=i(1);j<n(5)-i(1);j++)
    
25.     arr[i][j]=sum++;   第一大圈i为0  小圈j不断自增  00 01 02 03 04  这条边就搞定了
    
26.    }
    
27.    for(j=i;j<n-i;j++){    现在是右边的那条边  04 14 24 34 44  左角标递增  右角标不变  那就需要循环的变量要递增
    
28.     if(arr[j][n-i-1]==0)     
    
29.     arr[j][n-i-1]=sum++;    左角标为j递增    右角标第一大圈为4  也就是n(5)-i(0)-1  第二大圈为3 也就是n(5)-i(1)-1
    
30.    }
    
31.    for(j=n-i-1;j>=i;j--){   现在是下面那条边  40 41 42 43 44   题目是顺时针转 所以这从44 往40走   左角标不变 右角标递减   那就需要循环的变量要递减
    
32.     if(arr[n-i-1][j]==0)   第一大圈有5个元素(j=n(5)-i(0)-1;j>=i(0);j--)第二大圈有3个元素 (j=n(5)-i(1)-1;j>=i(1);j--)
    
33.     arr[n-i-1][j]=sum++;   左角标第一大圈为4 也就是n(5)-i(0)-1  第二大圈为3 也就是n(5)-i(1)-1  右角标为j递减
    
34.    }
    
35.    for(j=n-i-1;j>=i;j--){  最后是左边的那条边 40 30 20 10 00   左角标递减  右角标不变   那就需要循环的变量要递减
    
36.     if(arr[j][i]==0)
    
37.     arr[j][i]=sum++;    左角标为j递减  右角标第一大圈为i(0)  第二大圈为i(1)
    
38.    }
    
39. 
    
40. }
    
41.   if(n%2==1){  n为奇数 中间会多出一个
    
42.    arr[n/2][n/2]=sum;  这个就是 arr[2][2]   22
    
43.   }
    
44. 
    
45. 
    
46. 
    
47. public class MainClass {
    
48. public static void main(String[] args) {
    
49.   printArray(4);
    
50. }
    
51. 
    
52. public static void printArray(int n){
    
53.   int[][] arr = new int[n][n];
    
54.   int i,j;
    
55.   int sum = 1;
    
56.   for(i=0;i<n/2;i++){
    
57.    for(j=i;j<n-i;j++){
    
58.     if(arr[i][j]==0)
    
59.     arr[i][j]=sum++;
    
60.    }
    
61.    for(j=i;j<n-i;j++){
    
62.     if(arr[j][n-i-1]==0)
    
63.     arr[j][n-i-1]=sum++;
    
64.    }
    
65.    for(j=n-i-1;j>=i;j--){
    
66.     if(arr[n-i-1][j]==0)
    
67.     arr[n-i-1][j]=sum++;
    
68.    }
    
69.    for(j=n-i-1;j>=i;j--){
    
70.     if(arr[j][i]==0)
    
71.     arr[j][i]=sum++;
    
72.    }
    
73.   }
    
74.   if(n%2==1){
    
75.    arr[n/2][n/2]=sum;
    
76.   }
    
77.   
    
78.   for(i=0;i<n;i++){
    
79.    for(j=0;j<n;j++){
    
80.     System.out.print(arr[i][j]+"\t");
    
81.    }
    
82.    System.out.println();
    
83.   }
    
84. }
    
85. }

复制代码

黑马张扬 发表于 2012-7-12 00:20

高手啊...膜拜下{:3_53:}

你们都弱了 给你们看看最强的....


public class Main {
        /**
         * 回形打印数字
         * @param args
         */
        public static void main(String[] args){
                int num=11;  //这个是需要打印的数组的长和宽度，测试时请改变这个
            int flag=num;
                int number=1;
                int[][] shuZu=new int[num][num];
               
               
               
               
                for(int i=0;i<flag;i++){      //大循环，写入第i层回形
                        for(int j=i;j<flag;j++){    //写入上边 横
                                shuZu[i][j]=number;
                                  number++;
                        }
                        for(int k=i+1;k<flag;k++){  // 写入右边竖
                                shuZu[k][flag-1]=number;
                                number++;
                        }
                       
                        for(int a=flag-2;a>=i;a--){   //写入下边横
                                shuZu[flag-1][a]=number;
                                number++;
                        }
                        for(int b=flag-2;b>i;b--){   //写入左边竖
                                shuZu[b][i]=number;
                                number++;
                        }
                       
                  flag-=1;
                }
               
               
       
               
               
                for(int i=0;i<num;i++){   //打印整个数组
                        for(int j=0;j<num;j++){
                                System.out.print(shuZu[i][j]+" ");
                        }
                        System.out.println();
                       
                }
        }

}

蒋映辉 发表于 2012-7-12 09:05
你们都弱了 给你们看看最强的....

兄弟，没有最强只有更强，俺来写一个更强的！嘿嘿！:victory:

1. 
   
2. class Matrix
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int n=4;                                                                        // 数字矩阵的维数（可以修改其他值测试）
   
7.                 int[][] arr = new int[n][n];                                          // 申请二维矩阵空间
   
8.                 int num=1, x=0, y=-1;                                                // 初始化数据
   
9.                 while (num <= n*n)                                                   // 循环填入数据
   
10.                 {
    
11.                         while ( y+1<n  && arr[x][y+1]==0 ) arr[x][++y] = num++;        // 从左到右
    
12.                         while ( x+1<n  && arr[x+1][y]==0 ) arr[++x][y] = num++;        // 从上到下
    
13.                         while ( y-1>=0 && arr[x][y-1]==0 ) arr[x][--y]    = num++;        // 从右到左
    
14.                         while ( x-1>=0 && arr[x-1][y]==0 ) arr[--x][y]    = num++;        // 从下到上
    
15.                 }
    
16.                 // 输出矩阵
    
17.                 for (x=0; x<n; x++)
    
18.                 {        for (y=0; y<n; y++)
    
19.                         {
    
20.                                 System.out.print(arr[x][y]+"\t");
    
21.                         }
    
22.                         System.out.println();
    
23.                 }
    
24.         }
    
25. }
    

复制代码

韦念欣 发表于 2012-7-12 13:31
兄弟，没有最强只有更强，俺来写一个更强的！嘿嘿！

哈哈  确实   不过思路都差不多....