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. }
    

复制代码

打印不出来是因为最后的数没有存进数组吧……
因为用i<n*n的话  n为奇数时就无法判断最后一次从左到右的for循环

解决方法很简单  如果n为奇数   手动把n*n的值传入数组的中心角标   arr [n/2][n/2]

这个问题其实 我都没看懂，楼主的分析 让我理解了 赞一个

晕了   我还是复制下来运行一下看看

1. /*
   
2. 输出 n=5 的螺旋方阵
   
3.         1  2  3  4  5
   
4.         16 17 18 19 6
   
5.         15 24 25 20 7
   
6.         14 23 22 21 8
   
7.         13 12 11 10 9
   
8. 
   
9. */
   
10. class  Example001
    
11. {
    
12.         public static void main(String[] args)
    
13.         {
    
14.                        
    
15.                 int size = 5;
    
16.                 int arr[][] = new int[size][size];
    
17.                 int i, j, k = 0, n, m;
    
18.                 n = size;
    
19.                 for (i = 0; i < n; i++) {
    
20.                         // 顶边，从左到右，行不变列变
    
21.                         for (j = i; j <= n - i - 1; j++)
    
22.                                 arr[i][j] = ++k;// i=0进来是输出1、2、3、4、5； i=1进来输出17、18、19 ;i=3,输出25
    
23.                        
    
24.                         // 右边，从上到下，行变列不变
    
25.                         for (j = i + 1; j <= n - i - 1; j++)
    
26.                                 arr[j][n - i - 1] = ++k; // i=0进来是输出6、7、8、9 ； i=1进来输出20、21
    
27.                        
    
28.                         // 底边，从右到左，行不变列变
    
29.                         for (j = n - i - 2; j >= i; j--)
    
30.                                 arr[n - i - 1][j] = ++k; // i=0进来是输出10、11、12、13；i=1进来输出22、23
    
31.                        
    
32.                         // 左边，从下到上，行变列不变
    
33.                         for (j = n - i - 2; j >= i + 1; j--)
    
34.                                 arr[j][i] = ++k; // i=0进来是输出14、15、16 ;i=1进来输出24
    
35.                 }
    
36.                
    
37.                 for (i = 0; i < n; i++) {
    
38.                         for (j = 0; j < n; j++)
    
39.                                 System.out.print(arr[i][j] + "\t");
    
40.                         System.out.println();
    
41.                 }
    
42.                
    
43.                
    
44.                
    
45.         }
    
46. }
    

复制代码

涿郡丶二哥 发表于 2015-4-8 22:31
你是不是蚊子红？

不是{:3_53:}

你是不是蚊子红？

看不懂啊，待会好好想想

这个比较全面，厉害~~

fantacyleo 发表于 2015-4-7 23:30
我明白你的问题在哪儿了。我们的代码区别在于，转角处的位置交给谁来填。你的做法是，把转角位置作为新方 ...

哦   ，谢谢大哥，终于找出问题了{:3_64:}

可能是迭代的时候漏了最后一个

随缘就好 发表于 2015-4-7 23:21
我在看看哈

我明白你的问题在哪儿了。我们的代码区别在于，转角处的位置交给谁来填。你的做法是，把转角位置作为新方向的起点。我的做法是，转角的下一个位置作为新方向的起点。那么当遇到奇数时，最内层只有1个数，这个数实际上是扮演了4个转角的角色。当向右填充时，它是右和下方向的转角，右是不填充它的。当向下填充时，它是下和左方向的转角，下是不填充它的。以此类推就是所有方向都不填充它，最后就空着没人填了

fantacyleo 发表于 2015-4-7 23:13
已经告诉你了嘛：同样基于按层填充思路。当然看着像。不过我刚才试了一下，我这个代码实际上已经解决了奇 ...

我在看看哈{:3_65:}

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

随缘就好 发表于 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.         }

复制代码

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

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

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

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

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. }

复制代码

表示这个看不懂

太赞了！！！！！！