1. /*
   
2.         第四题：
   
3.         输出 n=5 的螺旋方阵
   
4.         1  2  3  4  5
   
5.         16 17 18 19 6
   
6.         15 24 25 20 7
   
7.         14 23 22 21 8
   
8.         13 12 11 10 9
   
9.        
   
10.         思路：
    
11.                 打印这一组数首先想到的是一行一行打印，但是很麻烦
    
12.                 然后我们可以考虑到用二维数组吧数字装起来打印
    
13.                 arr{{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}}
    
14.                 这样就是基本上解决这个问题了，数据存入有很多方法
    
15.                 我使用的是固定角标 一层一层向内输出
    
16.                 但是我的方法有一个弊端奇数时中心的最后打印不出
    
17. */
    
18. import java.util.Scanner;
    
19. class Day04_04
    
20. {
    
21.         public static void main(String[] args){
    
22.                 Scanner s = new Scanner (System.in);
    
23.                 while(true){
    
24.                         System.out.println("请输入一个正整数：");
    
25.                         int x = s.nextInt();
    
26.                         Alg(x);       
    
27.                 }
    
28. 
    
29.         }
    
30.         public static void Alg(int n){
    
31.                 int arr[][]=new int[n][n];                        //定义一个数组用于储存
    
32.                 for (int x=0,y=0,i=1,kx=0,ky=0;i<n*n;kx++,ky++){        //x,y分别用于做二维数组 的X，变量和y变量，i为当前二位数组的值，
    
33.                                                                                                                         //kx，ky分别代表着x的增量和y的增量，作用为循环向内移动一层
    
34.                         //这里是数据从左往右移动，X不变Y变，kx和ky在此处分别给x，y赋值
    
35.                         //表示数组角标向内一层，y<n-1-ky,是把y的可循环的值向内减一
    
36.                         //该循环打印的值是  1、2、3、4 ，17、18
    
37.                         for (x=kx,y=ky;y<n-1-ky;y++,i++){
    
38.                                 arr[x][y]=i;//x=0;y=4
    
39.                         }
    
40.                         //这里是数据从上往下移动，Y不变X变，x,y刚好可以沿用上一次的值
    
41.                         //表示数组角标向内一层，x<n-1-ky,是把x的可循环的值向内减一
    
42.                         //该循环打印的值是5、6、7、8， 19、20                       
    
43.                         for (;x<n-1-kx;x++,i++){
    
44.                                 arr[x][y]=i;//x=4;y=4
    
45.                         }
    
46.                         //这里是数据从右往左移动，X不变Y变，x,y刚好可以沿用上一次的值
    
47.                         //表示数组角标向内一层，y>0+ky,是把y的可循环的值向内减一
    
48.                         //该循环打印的值是 9\1\0\11\12,21\22
    
49.                         for (;y>0+ky;y--,i++){
    
50.                                 arr[x][y]=i;//x=4;y=0
    
51.                         }
    
52.                         //这里是数据从下往上移动，Y不变X变，x,y刚好可以沿用上一次的值
    
53.                         //表示数组角标向内一层，x>0+kx,是把x的可循环的值向内减一
    
54.                         //打印的值分别是13\14\15\16,23,24       
    
55.                         for (;x>0+kx;x--,i++){
    
56.                                 arr[x][y]=i;//y=0;x=0
    
57.                         }
    
58.                        
    
59.                 }       
    
60.                 //然后我们会发现当我们输入奇数的时候最后一个值打印不出求各位大神打救
    
61.                 //这个就是把最后一个值打印出来的判断
    
62.                 if(n%2!=0){
    
63.                         int m=(n-1)/2;
    
64.                         arr[m][m]=n*n;
    
65.                 }
    
66.         //        遍历数组，打印
    
67.                 for (int i=0;i<n ;i++ )
    
68.                 {
    
69.                         for (int j=0;j<n ;j++ )
    
70.                         {
    
71.                                 System.out.print(arr[i][j]+"\t");
    
72.                         }
    
73.                         System.out.println();
    
74.                 }
    
75.         }
    
76. }
    

复制代码

不错，转转就转晕了，注释写的很好

作为还在hello world混的，
我表示我看不明白

必须赞一个，我头都转晕了我，都没看出来！

果然代码还是自己写的才看的清楚··

还是有点没看明白

转晕了，不过注释写的很好！

求给位帮我看看啊，我中间那个用了if强行打印的，但是应该可以全部用for打印的啊

转成螺丝了  不明白

好厉害啊！！！！！！！

tu3 发表于 2015-4-7 21:21
作为还在hello world混的，
我表示我看不明白

你的黑马币-4是怎么做到的？？？？

i=1;i<n*n....这才到24吧。。。加个等于号应该就可以了吧

大神都，表示菜鸟还看不明白

dxf578939729 发表于 2015-4-7 21:53
i=1;i

加个等号整个程序就疯掉了，因为25的时候没有满足的for然后就无线循环了

太赞了！！！！！！

表示这个看不懂

同样基于按层填充思路，递归版本。按层填充，应该都是要考虑奇偶差别的

1. public class Tests {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 int[][] a = new int[8][8];
   
5.                 fill(a, 0, 1);
   
6. //                fill1(a);
   
7.                 printSquare(a);
   
8.                
   
9.         }
   
10.         
    
11.         public static void fill(int[][] square, int layer, int num) {
    
12.                 int len = square.length - layer * 2;
    
13.                 if (len == 0)
    
14.                         return;
    
15.                 if (len == 1) {
    
16.                         square[layer][layer] = num;
    
17.                         return;
    
18.                 }
    
19.                 int row = layer, col = layer;
    
20.                 for (;col < square.length - layer; col++)
    
21.                         square[row][col] = num++;
    
22.                
    
23.                 for (col--, row++;row < square.length - layer; row++)
    
24.                         square[row][col] = num++;
    
25.                 for (row--, col--;col >= layer; col--)
    
26.                         square[row][col] = num++;
    
27.                 for (col++, row--; row > layer; row--)
    
28.                         square[row][col] = num++;
    
29.                 fill(square, layer+1, num);
    
30.         }
    
31. }

复制代码

大神的世界我们永远不懂，还是继续去敲hello world

fantacyleo 发表于 2015-4-7 22:42
同样基于按层填充思路，递归版本。按层填充，应该都是要考虑奇偶差别的
...

额  大哥你这个好像和我那个好像，但是也是一种的方式；但是没有解决我的问题啊{:3_62:}

随缘就好 发表于 2015-4-7 23:07
额  大哥你这个好像和我那个好像，但是也是一种的方式；但是没有解决我的问题啊 ...

已经告诉你了嘛：同样基于按层填充思路。当然看着像。不过我刚才试了一下，我这个代码实际上已经解决了奇偶判断问题：

1. public static void fill(int[][] square, int layer, int num) {
   
2.                 int start = square.length - layer * 2;
   
3.                 if (start <= 0)
   
4.                         return;
   
5.        
   
6.                 int row = layer, col = layer;
   
7.                 for (;col < square.length - layer; col++)
   
8.                         square[row][col] = num++;
   
9.                
   
10.                 for (col--, row++;row < square.length - layer; row++)
    
11.                         square[row][col] = num++;
    
12.                 for (row--, col--;col >= layer; col--)
    
13.                         square[row][col] = num++;
    
14.                 for (col++, row--; row > layer; row--)
    
15.                         square[row][col] = num++;
    
16.                 fill(square, layer+1, num);
    
17.           
    
18.          
    
19.         }

复制代码