前两天的一道考试题，刚拿到手头都大了，不过功夫不负有心人，经过大半天努力 还是搞出来了。可能方法有点笨了，有高手有更好的方法，求指点
题目是这样的：  写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
1  2  3    4
12 13 14 5
11 16 15 6
10  9   8  7

1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. public class Test9 {
   
6. 
   
7.         public static void main(String[] args) {
   
8. 
   
9.                 // 输入数组长度
   
10.                 System.out.print("请输入数组长度:");
    
11.                 Scanner sc = new Scanner(System.in);
    
12.                 int n = sc.nextInt();
    
13. 
    
14.                 // 打印从1开始的自然数开始由方阵的最外圈向内螺旋方式地顺序排列的数组
    
15.                 printArray(n);
    
16. 
    
17.         }
    
18. 
    
19.         /**
    
20.          * 打印指定长度的等长二维数组
    
21.          * */
    
22.         public static void printArray(int n) {
    
23. 
    
24.                 // 构造一个空的数组
    
25.                 Integer[][] it = new Integer[n][n];
    
26.                 // 将起始元素设置为 1
    
27.                 it[0][0] = 1;
    
28.                 // 定义起始元素Point对象
    
29.                 Point p = new Point(0, 0, 1);
    
30. 
    
31.                 // 设定初始方向，向右
    
32.                 int flg = 1;
    
33.                 // 代表数组设值得方向
    
34.                 Direction d = null;
    
35.                 // 一次循环可以设值的个数，为零代表已经将数组填满
    
36.                 int step = 0;
    
37. 
    
38.                 // 循环维数组设置从自然数1开始的连续的值
    
39.                 while (true) {
    
40. 
    
41.                         // 方向依次为右下左上
    
42.                         d = Direction.getDirection(flg);
    
43.                         // 获取本次循环可以设置的元素个数
    
44.                         step = Direction.nextPoint(p, d, it);
    
45. 
    
46.                         // 为零代表已经将数组填满
    
47.                         if (step == 0) {
    
48.                                 break;
    
49.                         }
    
50.                         // 返回下次循环开始的点
    
51.                         p = setValue(p, d, step, p.getV(), it);
    
52. 
    
53.                         // 方向依次改变
    
54.                         flg++;
    
55.                 }
    
56. 
    
57.                 // 循环打印给数组中的值
    
58.                 for (int i = 0; i < it.length; i++) {
    
59. 
    
60.                         for (int j = 0; j < it[i].length; j++) {
    
61. 
    
62.                                 System.out.print(it[i][j] + "\t");
    
63.                         }
    
64.                         // 折行
    
65.                         System.out.println();
    
66.                 }
    
67.         }
    
68. 
    
69.         /**
    
70.          * 给定点，给定方向和该方向上的空元素数，将该方向上的空元素依次设值，并返回最后一个元素，返回的元素需要改变方向
    
71.          * */
    
72.         public static Point setValue(Point p, Direction d, int step, int value,
    
73.                         Integer[][] it) {
    
74. 
    
75.                 // 获取元素坐标和方向
    
76.                 int a = p.getA();
    
77.                 int b = p.getB();
    
78.                 int y = d.getY();
    
79.                 int x = d.getX();
    
80. 
    
81.                 // 循环累加给定点的值，并赋到数组中去
    
82.                 for (int k = 0; k < step; k++) {
    
83. 
    
84.                         it[a = a + y][b = b + x] = ++value;
    
85.                 }
    
86. 
    
87.                 // 返回最后一个点
    
88.                 return new Point(a, b, value);
    
89.         }
    
90. 
    
91. }
    
92. 
    
93. /**
    
94. * 代表数组中一个数组元素
    
95. * */
    
96. class Point {
    
97. 
    
98.         // a表示二维维数，
    
99.         private int a = 0;
    
100.         // b表示一维脚标
     
101.         private int b = 0;
     
102.         // v表示数组元素的值
     
103.         private int v = 0;
     
104. 
     
105.         public int getA() {
     
106.                 return a;
     
107.         }
     
108. 
     
109.         public int getB() {
     
110.                 return b;
     
111.         }
     
112. 
     
113.         public int getV() {
     
114.                 return v;
     
115.         }
     
116. 
     
117.         // 构造方法
     
118.         public Point(int a, int b, int v) {
     
119.                 this.a = a;
     
120.                 this.b = b;
     
121.                 this.v = v;
     
122.         }
     
123. }
     
124. 
     
125. /**
     
126. * 方向类，将二维数组看成坐标系，左右为x轴，上下为y轴，将方向表示为(y,x)对应数组脚标
     
127. * 方向向右表示为(0,1）,向下为(1,0),向左(0,-1)，向上(-1,0)
     
128. * */
     
129. class Direction {
     
130. 
     
131.         // 向右为(0,1）
     
132.         private static Direction rD = new Direction(0, 1);
     
133.         // 向下为(1,0)
     
134.         private static Direction dD = new Direction(1, 0);
     
135.         // 向左为(0,-1)
     
136.         private static Direction lD = new Direction(0, -1);
     
137.         // 向上为(-1,0)
     
138.         private static Direction uD = new Direction(-1, 0);
     
139. 
     
140.         // 定义y轴和x轴的坐标值
     
141.         private int y = 0;
     
142.         private int x = 0;
     
143. 
     
144.         public int getY() {
     
145.                 return y;
     
146.         }
     
147. 
     
148.         public int getX() {
     
149.                 return x;
     
150.         }
     
151. 
     
152.         // 构造方法，初始化方向类即指定相应坐标
     
153.         public Direction(int y, int x) {
     
154.                 this.y = y;
     
155.                 this.x = x;
     
156.         }
     
157. 
     
158.         /**
     
159.          * 给定原点和方向，获取可以移动的步数
     
160.          */
     
161.         public static int nextPoint(Point p, Direction d, Integer[][] it) {
     
162. 
     
163.                 // 接收参数的坐标值
     
164.                 int a = p.getA();
     
165.                 int b = p.getB();
     
166.                 int v = p.getV();
     
167.                 // 可以移动的步数
     
168.                 int step = 0;
     
169.                 // 移动的方向
     
170.                 int direct = 0;
     
171.                 Point newP = null;
     
172. 
     
173.                 // 判断移动的方向
     
174.                 if ((direct = d.getX()) != 0) {
     
175.                         if (direct > 0) {
     
176. 
     
177.                                 // x轴向右移动，直到不为空，得到移动的步数
     
178.                                 while (true) {
     
179.                                         if (isNullPoint(a, ++b, it)) {
     
180.                                                 step++;
     
181.                                                 continue;
     
182.                                         }
     
183.                                         break;
     
184.                                 }
     
185.                         } else {
     
186. 
     
187.                                 // x轴向左移动，直到不为空，得到移动的步数
     
188.                                 while (true) {
     
189.                                         if (isNullPoint(a, --b, it)) {
     
190.                                                 step++;
     
191.                                                 continue;
     
192.                                         }
     
193.                                         break;
     
194.                                 }
     
195.                         }
     
196.                 } else {
     
197. 
     
198.                         // 在y轴上移动
     
199.                         direct = d.getY();
     
200. 
     
201.                         if (direct > 0) {
     
202. 
     
203.                                 // 在y轴上向下移动
     
204.                                 while (true) {
     
205.                                         if (isNullPoint(++a, b, it)) {
     
206.                                                 step++;
     
207.                                                 continue;
     
208.                                         }
     
209.                                         break;
     
210.                                 }
     
211.                         } else {
     
212. 
     
213.                                 // 在y轴上向上移动
     
214.                                 while (true) {
     
215.                                         if (isNullPoint(--a, b, it)) {
     
216.                                                 step++;
     
217.                                                 continue;
     
218.                                         }
     
219.                                         break;
     
220.                                 }
     
221.                         }
     
222.                 }
     
223. 
     
224.                 return step;
     
225. 
     
226.         }
     
227. 
     
228.         /**
     
229.          * 给定数组的维数脚标，判断数组中的某个元素是否为空 false不为空，true为空
     
230.          * */
     
231.         public static boolean isNullPoint(int a, int b, Integer[][] it) {
     
232. 
     
233.                 // 维数脚标不合法，返回false
     
234.                 if (a >= it.length || b >= it.length || a < 0 || b < 0) {
     
235.                         return false;
     
236.                 }
     
237.                 // 判断值是否为空
     
238.                 if (it[a][b] == null) {
     
239.                         return true;
     
240.                 } else {
     
241.                         return false;
     
242.                 }
     
243.         }
     
244. 
     
245.         /**
     
246.          * 获取移动的方向，首先向右移动
     
247.          */
     
248.         public static Direction getDirection(int flg) {
     
249. 
     
250.                 // 方向依次是右下左上，通过取余判断
     
251.                 if (flg % 4 == 1) {
     
252.                         return rD;
     
253.                 } else if (flg % 4 == 2) {
     
254.                         return dD;
     
255.                 } else if (flg % 4 == 3) {
     
256.                         return lD;
     
257.                 } else {
     
258.                         return uD;
     
259.                 }
     
260.         }
     
261. 
     
262. }
     

复制代码

代码我都没敢看  ，这么简单的代码 ， 我写了这么多 ， 我也就是醉了 ，  拿到题目多思考  
有了思路代码就容易了，别写了代码再来想思路。
敲代码之前一定要有自己的逻辑思路

1. 
   
2. public class Rows {
   
3.         public static void main(String[] args) {
   
4.                 int arr[][] =new int[5][5];
   
5.                 int i = 0;
   
6.                 int j = 0;
   
7.                 int count = 1;
   
8.                 boolean flag = true;
   
9.                 for(int num = 1;num<=25;num++){
   
10.                         arr[i][j]=num;
    
11.                
    
12.                         if(flag){
    
13.                                 j++;
    
14.                                 if(j>5-count){
    
15.                                         i++;
    
16.                                         j--;
    
17.                                         if(i>5-count){
    
18.                                                 flag=false;
    
19.                                                 i--;
    
20.                                                
    
21.                                         }
    
22.                                 }
    
23.                         }
    
24.                         if(!flag){
    
25.                                 j--;
    
26.                                 if(j<count-1){
    
27.                                         i--;
    
28.                                         j++;
    
29.                                         if(i<count){
    
30.                                                 flag=true;
    
31.                                                 i++;
    
32.                                                 j++;
    
33.                                                 count++;
    
34.                                         }
    
35.                                 }
    
36.                                
    
37.                         }
    
38.                        
    
39.                 }
    
40.                 for(i=0;i<5;i++){
    
41.                         for(j=0;j<5;j++){
    
42.                                 System.out.print(arr[i][j]+"\t");
    
43.                         }
    
44.                         System.out.println();
    
45.                 }
    
46.         }
    
47. }

复制代码

后面一种方式更加简单，通过修改区调整i，j的位置区设定值。

给力啊哈哈

完爆的节奏~

默默丶 发表于 2014-12-5 18:51
代码我都没敢看  ，这么简单的代码 ， 我写了这么多 ， 我也就是醉了 ，  拿到题目多思考  
有了思路代码就 ...

瞬间感觉高大上

不明觉厉！

不都说，赞一个

1. <div class="blockcode"><blockquote>
   
2. class Luoxuan
   
3. {
   
4.         //打印数组
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 int n=5;
   
8.                 int arr[][]=fun(n);
   
9.                
   
10.                
    
11.                 for(int i=0;i<n;i++)
    
12.                 {
    
13.                         for(int j=0;j<n;j++)
    
14.                         {
    
15.                                 System.out.print(arr[i][j]+"\t");
    
16.                         }
    
17.                         System.out.println();
    
18.                 }
    
19.                
    
20.         }
    
21.         //数组带入值的函数fun
    
22.         public static int[][] fun(int n)
    
23.         {       
    
24.         //两种情况：n=偶数；n=奇数。
    
25.        
    
26.        
    
27.        
    
28.                 int arr[][]=new int[n][n];
    
29.                 int num=1,t=n;
    
30.                 //jishu是外循环次数，螺旋层数。
    
31.                 int jishu=(n+1)/2;
    
32.                 //n=奇数。
    
33.                 if(t%2==1)
    
34.                 arr[t-t/2-1][t-t/2-1]=t*t;
    
35.                 //n=偶数。
    
36.                 while(jishu>0)
    
37.                 {
    
38.                         for(int i=t-n,j=t-n;j<n-1;j++)
    
39.                                 {
    
40.                                 arr[i][j]=num;num++;
    
41.                                 }
    
42.                         for(int i=t-n,j=n-1;i<n-1;i++)
    
43.                                 {
    
44.                                 arr[i][j]=num;num++;
    
45.                                 }
    
46.                         for(int i=n-1,j=n-1;j>t-n;j--)
    
47.                                 {
    
48.                                 arr[i][j]=num;num++;
    
49.                                 }
    
50.                         for(int i=n-1,j=t-n;i>t-n;i--)
    
51.                                 {
    
52.                                 arr[i][j]=num;num++;
    
53.                                 }
    
54.                        
    
55.                         n--;
    
56.                         jishu--;
    
57.                                
    
58.                 }
    
59.                 return arr;
    
60.         }       
    
61. }

复制代码

最重要的是要找到规律。楼上的代码看不懂，我水平有限。自己想了一种容易想的方法。如下图：

奇数和偶数的情况不同是调试时候发现的，要从调试中找错误。

默默丶 发表于 2014-12-5 18:51
代码我都没敢看  ，这么简单的代码 ， 我写了这么多 ， 我也就是醉了 ，  拿到题目多思考  
有了思路代码就 ...

哈哈，确实，不过我这是照着面向对象来的。当然放到这个具体问题来说，肯定是小题大做，哈哈:D

这个题有啥意义吗。完全是逗你玩的没有循环

评论收藏。给力的回答

高慧觉 发表于 2014-12-6 10:24
最重要的是要找到规律。楼上的代码看不懂，我水平有限。自己想了一种容易想的方法。如下图：奇数和偶数的情 ...

你的图很受用啊，当时想复杂了

1. package cn.jx.test2;
   
2. 
   
3. public class test0 {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                
   
7.                 int n = 11;
   
8.                 int arr[][] = new int[n][n];
   
9.                 int num = 1;
   
10.                 int a = 0,b = 0;
    
11.                 int m = n;
    
12.                 if(n%2!=0){
    
13.                         arr[(n-1)/2][(n-1)/2] = n*n;
    
14.                 }
    
15.                 for(int i=0; i<((n+1)/2);i++){
    
16.                         int x = 0,y = 1;
    
17.                         int f=0;
    
18.                         while(f++<4){
    
19.                                 for(int j=0;j<m-1;j++){
    
20.                                         arr[a][b]=num++;
    
21.                                         a=a+x;b=b+y;
    
22.                                 }
    
23.                                 x=x+y;y=y-x;x=x+y;
    
24.                         }
    
25.                         m = m-2;
    
26.                         a = a + 1;
    
27.                         b = b + 1;
    
28.                 }
    
29.                
    
30.                 for(int j=0;j<n;j++){
    
31.                         for(int k=0;k<n;k++){
    
32.                                 System.out.print(arr[j][k] + "\t");
    
33.                         }
    
34.                         System.out.println();
    
35.                 }
    
36.         }
    
37. }
    

复制代码

不明觉励。