/*
需求：
        写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
        如： n = 4 则打印：                                
        1     2     3     4
        12   13  14    5
        11   16  15    6
        10    9    8      7
思路：
        1.二维数组的特殊遍历（螺旋遍历）
        2.把整数赋值给特殊遍历的二维数组
*/
class ArryTest  
{
        public static void main(String[] args)
        {
                //定义变量、创建二维数组               
                int a = 0;
                int b = 0;
                int num = 0;
                int[][] arr = new int[4][4];
                //遍历数组
                for(int n = 4;n>1;n--){
                        for(;b<=n-1;++b){
                                arr[a][b] = ++num;
                        }
                        --b;
                        ++a;         
                        for(;a<=n-1;++a){
                                arr[a][b] = ++num;
                        }
                        --a;
                        --b;
                        for(;b>=n-1-a;--b){
                                arr[a][b] = ++num;
                        }
                        ++b;
                        --a;
                        for(;a>b;a--){
                                arr[a][b] = ++num;
                        }
                        ++b;
                        ++a;
                }
                //打印输出
                for(int x=0; x<arr.length; x++) {
                        for(int y=0; y<arr[x].length; y++) {
                                System.out.print(arr[x][y]+"\t");
                        }
                        System.out.println();
                }
        }
}
我做的结果是：如图
求大神帮忙 解析一下  在这个思路下  我的代码  问题出在哪？

你的思路太诡异了..表示没看懂..下面是我写的

1. class SpiralTraversal{
   
2.         public static void main(String[] args){
   
3.                 //定义变量 创建二维数组
   
4.                 int length = 5;                  
   
5.                 int a = 0;
   
6.                 int b = 0;
   
7.                 int num = 1;
   
8.                 int[][] arr = new int[length][length];
   
9.                 //遍历数组
   
10.                 for (int n=length-1; n>0; n-=2){
    
11.                         for (int i=0; i<n; i++)
    
12.                                 arr[a][b++] = num++;
    
13.                         for (int i=0; i<n; i++)
    
14.                                 arr[a++][b] = num++;
    
15.                         for (int i=0; i<n; i++)
    
16.                                 arr[a][b--] = num++;
    
17.                         for (int i=0; i<n; i++)
    
18.                                 arr[a--][b] = num++;
    
19.                         a++;
    
20.                         b++;
    
21.                 }
    
22.                 if (length%2 == 1)
    
23.                         arr[a][b] = num;
    
24.                 //打印输出
    
25.                 for (int x=0; x<arr.length; x++){
    
26.                         for (int y=0; y<arr[x].length; y++){
    
27.                                 System.out.print(arr[x][y]+"\t");
    
28.                         }
    
29.                         System.out.println();
    
30.                 }
    
31.         }
    
32. }

复制代码

云狐 发表于 2015-8-29 19:23
你的思路太诡异了..表示没看懂..下面是我写的

谢谢  

xlalisa 发表于 2015-8-29 19:31

代码有点问题  不过还是要谢谢  帮忙解决问题

有点难度，说下我的思路：
附件中有图，顺时针旋转，
首先从方向1开始，此方向，行不变，列逐加
再到方向2：行逐加，列不变
又到方向3：行不变，列逐减
最后到方向4：行逐减，列不变

每次切换方向的条件不一样，看代码注释

class Test {
        public static void main(String[] args){
                int squareSize = 4;
                int direction = 1; // 1-向右，2-向下，3-向左，4-向上。最初时向右
                int[][] array = new int[squareSize][squareSize];
                int r = 0, c = 0;
                for(int i = 1; i<= squareSize*squareSize; i++){
                        array[r][c] = i;
                        switch(direction){
                                case 1:
                                        /*当列数加到squareSize-1或下一个数组有值时，换向*/
                                        if(c == squareSize-1 || array[r][c+1] != 0){
                                                r++;
                                                direction = 2;
                                        }else
                                                c++;
                                        break;
                                case 2:       
                                        /*当行数加到squareSize-1或下一个数组有值时，换向*/
                                        if(r == squareSize-1 || array[r+1][c] != 0){
                                                c--;
                                                direction = 3;
                                        }else
                                                r++;
                                        break;
                                case 3:       
                                        /*当列数减到0或下一个数组有值时，换向*/
                                        if(c == 0 || array[r][c-1] != 0){
                                                r--;
                                                direction = 4;
                                        }else
                                                c--;
                                        break;
                                case 4:       
                                        /*下一个数组有值时换向*/
                                        if(array[r-1][c] != 0){
                                                c++;
                                                direction = 1;
                                        }else
                                                r--;
                                        break;
                                default:
                                        System.out.println("发生异常");
                        }
                }
                System.out.println("以下为"+squareSize+"方阵输出结果：");
                for(int i=0; i<squareSize;i++){
                        for(int j=0; j<squareSize;j++){
                                System.out.print(array[i][j]+"\t");
                        }
                        System.out.println();
                }
        }
}

谢谢   

xlalisa 发表于 2015-8-29 19:54
你放eclipse里面跑一下。没问题的

  非常感谢

xlalisa 发表于 2015-8-29 19:54
你放eclipse里面跑一下。没问题的

谢谢

1. class Lx
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int size = 5;
   
6.                 int arr[][] = new int[size][size];
   
7.                 int i,j,k=0,n;
   
8.                 n=size;
   
9.                 for(i=0;i<n;i++)
   
10.                 {
    
11.                         //顶边
    
12.                         for(j=i;j<n-i;j++)
    
13.                         {
    
14.                                 arr[i][j]=++k;
    
15.                         }
    
16.                         //右边
    
17.                         for(j=i+1;j<=n-i-1;j++)
    
18.                         {
    
19.                                 arr[j][n-i-1]=++k;
    
20.                         }
    
21.                         //底边
    
22.                         for(j=n-i-2;j>=i;j--)
    
23.                         {
    
24.                                 arr[n-i-1][j]=++k;
    
25.                         }
    
26.                         //左边
    
27.                         for(j=n-i-2;j>i;j--)
    
28.                         {
    
29.                                 arr[j][i]=++k;
    
30.                         }
    
31.                 }
    
32.                 //打印
    
33.                 for(i=0;i<n;i++)
    
34.                 {
    
35.                         for(j=0;j<n;j++)
    
36.                         {
    
37. 
    
38.                                 System.out.print(arr[i][j]+"\t");
    
39.                         }
    
40.                         System.out.println();
    
41.                 }
    
42. 
    
43.         }
    
44. }
    
45. 
    
46. 我是这样打的:
    
47. 顶: n个 oooo
    
48. 右:n-1个
    
49. o
    
50. o
    
51. o
    
52. 底:n-1个 ooo
    
53. 左:n-2个
    
54. o
    
55. o
    

复制代码

据说用集合比较好做

云狐 发表于 2015-8-29 19:23
你的思路太诡异了..表示没看懂..下面是我写的

这个代码挺好看的，怎么想出来的，好难想出来。。。

不懂，看大神解答

1. //改了成更通用的矩阵螺旋输出自然数。
   
2. //因为每一圈之后所剩下的矩阵的行和列都会减2，为了提高效率改成了，圈数最多限制为(min+1)/2。
   
3. 
   
4. import java.util.Scanner;
   
5. class Test {
   
6.         public static void main(String[] args){
   
7.                 Scanner sc = new Scanner(System.in);
   
8. 
   
9.                 System.out.println("输入行数：");
   
10.                 int m = sc.nextInt(); //行
    
11.                 System.out.println("再输入列数：");
    
12.                 int n = sc.nextInt();//列
    
13.                 int num = 1;
    
14.                 int[][] arr = new int[m][n];
    
15. 
    
16.                 int min = m>n ? m : n;
    
17.                 //螺旋进入矩阵
    
18.                 for(int q=0;q<(min+1)/2;q++){ //q为圈数，r为行数，c为列数
    
19.                         //从左到右，行=，列+
    
20.                         for(int c=q; c<n-q; c++)
    
21.                                 arr[q][c] = num++;
    
22.                         if(q+1 == m-q)
    
23.                                 break;
    
24.                         
    
25.                         //从上到下，行+，列=
    
26.                         for(int r=q+1; r<m-q; r++)
    
27.                                 arr[r][n-1-q] = num++;
    
28.                         if(q-1 == n-1-q-1)
    
29.                                 break;
    
30.                         
    
31.                         //从右到左，行=，列-
    
32.                         for(int c=n-1-q-1; c>=q;c--)
    
33.                                 arr[m-1-q][c] = num++;
    
34.                         if(q == m-1-q-1)
    
35.                                 break;
    
36.                         
    
37.                         //从下到上，行-，列=
    
38.                         for(int r=m-1-q-1; r>q; r--)
    
39.                                 arr[r][q] = num++;
    
40.                         if(q+1 == n-1-q)
    
41.                                 break;
    
42.                 }
    
43. 
    
44.                 //打印输出
    
45.                 for(int x=0; x<arr.length; x++) {
    
46.                                 for(int y=0; y<arr[x].length; y++) {
    
47.                                                 System.out.print(arr[x][y]+"\t");
    
48.                                 }
    
49.                                 System.out.println();
    
50.                 }
    
51.         }
    
52. }

复制代码