打印回型数组 回型矩阵 环形数组

论坛上的一个帖子http://topic.csdn.net/u/20081202/13/834d7cb0-a063-4754-a702-612f3053bd60.html?seed=996406603

1    2  3  4  5
14  15  16  17  6
13  20  19  18  7
12  11  10  9  8

请问这样一个矩阵怎么打印出来啊

 

解决方法(适用范围：非素数的int型数组)：

 由总元素的数目n来决定数组的行数和列数,
 n的最中间约数作为行数的行数和列数,比如:20
 则行数为4,列数为5;再比如24,
 则行数为4,列数为6,再比如25,
则行数和列数均为5

 

下面为程序代码

1. /**
2.  * 
3.  * @author hp9016
4.  * @version 1.0
5.  * 功能说明：实现回型数组的打印要求
6.  * 
7.  */
8. public class ForLouZhu {
10.     /**
11.      * 主函数
12.      */
13.     public static void main(String[] a){
14.         
15.         /*
16.          * n为总元素个数
17.          * 可以修改n的值，看看运行效果
18.          */
19.         int n = 24;
20.         new Array(n).print();
21.     }
22. }
24. /**
25.  * 
26.  * @author hp9016
27.  * @version 1.0
28.  * 功能说明：存储行数和列数
29.  * 
30.  */
31. class Row {
32.     
33.     /*
34.      * 行数
35.      */
36.     private static int row;
37.     
38.     /*
39.      * 列数,即每行多少个元素
40.      */
41.     private static int length;
42.     
43.     public static int getLength() {
44.         return length;
45.     }
46.     public static void setLength(int length) {
47.         Row.length = length;
48.     }
49.     public static int getRow() {
50.         return row;
51.     }
52.     public static void setRow(int row) {
53.         Row.row = row;
54.     }
55. }
57. /**
58.  * 
59.  * @author hp9016
60.  * @version 1.0
61.  * 功能说明：实现楼主要求
62.  * 
63.  */
64. class Array {
65.     
66.     /*
67.      * 一共有多少个元素,即二维数组的总元素数
68.      */
69.     private int n = 0;    
70.     
71.     /*
72.      * 行数
73.      */
74.     private int row = 0;
75.     
76.     /*
77.      * 列数,即每行多少个元素
78.      */
79.     private int length = 0;
80.     
81.     /*
82.      * 欲打印的数组
83.      */
84.     private int[][] arr;
85.     
86.     /**
87.      * 构造方法
88.      * @param n 总元素个数
89.      */
90.     public Array(int n){
91.         this.n = n;
92.     }
93.     
94.     /**
95.      * 打印数组
96.      *
97.      */
98.     public void print(){
99.         
100.         /*
101.          * 填充数组
102.          */
103.         setArray();
104.         for(int i = 0; i< row; i++){
105.             for(int j = 0; j < length; j++){
106.                 System.out.print(arr[i][j] + "  ");
107.             }
108.             System.out.println();
109.         }
110.     }
111.     
112.     /**
113.      * 由总元素的数目n来决定数组的行数和列数,
114.      * n的最中间约数作为行数的行数和列数,比如:20
115.      * 则行数为4,列数为5;再比如24,
116.      * 则行数为4,列数为6,再比如25,
117.      * 则行数和列数均为5
118.      *
119.      */
120.     private void setRow(){
121.         int temp = (n + 1)/2;
122.         int length = n;
123.         
124.         for(int i = 1; i <= temp; i++){
125.             
126.             if(i >= length){
127.                 
128.                 /*
129.                  * 存储到bean中
130.                  */
131.                 Row.setLength(length);
132.                 Row.setRow(n / length);
133.                 break;
134.             }
135.             
136.             if(n % i == 0){
137.                 length = n / i;
138.             }
139.         }
140.     }
141.     
142.     /**
143.      * 核心函数
144.      * 按楼主要求--绕圈填充数组
145.      *
146.      */
147.     private void setArray(){
148.         
149.         /*
150.          * 临时行号
151.          */
152.         int tempRow = 0;
153.         
154.         /*
155.          * 临时列号
156.          */
157.         int tempLength = 0;
158.         
159.         /*
160.          * 当前最小没有被填充的行号
161.          */
162.         int minRow = 0;
163.         
164.         /*
165.          * 当前最小没有被填充的列号
166.          */
167.         int minLength = 0;
168.         
169.         /*
170.          * 当前最大没有被填充的行号
171.          */
172.         int maxRow = row;
173.         
174.         /*
175.          * 当前最大没有被填充的列号
176.          */
177.         int maxLength = length;
178.         
179.         /*
180.          * 记录总元素数目
181.          */
182.         int i =1;
183.         
184.         setRow();
185.         row = Row.getRow();
186.         length = Row.getLength();
187.         arr = new int[row][length];
188.         arr[0][0] = 1;
189.         maxRow = row - 1;
190.         maxLength = length - 1;
191.         
192.         /*
193.          * 本while的注释中的"最小"指:没有被填充的最小元素的下标
194.          * "最大"指:没有被填充的最大元素的下标
195.          * 填充的顺序如下:1>2>3>4
196.          * |--1--|
197.          * 4     2
198.          * |--3--|
199.          * 
200.          */
201.         while(i < n){
202.             
203.             /*
204.              * 行号最小,列号最小时,类似于上图的1:
205.              * 从左向右这个方向填充数组
206.              */
207.             if(tempRow == minRow && tempLength == minLength ){
208.                 
209.                 /*
210.                  * 设置最大列数
211.                  */
212.                 while(arr[tempRow][maxLength] != 0 &
213.                         maxLength > 0){
214.                     maxLength--;
215.                 }
216.                 
217.                 /*
218.                  * 从左向右这个方向填充数组
219.                  */
220.                 while(tempLength < maxLength){
221.                     tempLength++;
222.                     i++;
223.                     arr[tempRow][tempLength] = i;
224.                 }
225.             }
226.             
227.             /*
228.              * 行号最小,列号最大时,类似于上图的2:
229.              * 从上向下这个方向填充数组
230.              */
231.             if(tempRow == minRow && tempLength == maxLength ){
232.                 
233.                 /*
234.                  * 设置最大行数
235.                  */
236.                 while(arr[maxRow][tempLength] != 0 &
237.                         maxRow > 0){
238.                     maxRow--;
239.                 }
240.                 
241.                 /*
242.                  * 从上向下这个方向填充数组
243.                  */
244.                 while(tempRow < maxRow){
245.                     tempRow++;
246.                     i++;
247.                     arr[tempRow][tempLength] = i;
248.                 }
249.             }
250.             
251.             /*
252.              * 行号最大,列号最大时,类似于上图的3:
253.              * 从右向左这个方向填充数组
254.              */
255.             if(tempRow == maxRow && tempLength == maxLength ){
256.                 
257.                 /*
258.                  * 设置最小列数
259.                  */
260.                 while(arr[tempRow][minLength] != 0 &
261.                         minLength < length - 1){
262.                     minLength++;
263.                 }
264.                 
265.                 /*
266.                  * 从右向左这个方向填充数组
267.                  */
268.                 while(tempLength > minLength){
269.                     tempLength--;
270.                     i++;
271.                     arr[tempRow][tempLength] = i;
272.                 }
273.             }
274.             
275.             /*
276.              * 行号最大,列号最大时,类似于上图的4:
277.              * 从下向上这个方向填充数组
278.              */
279.             if(tempRow == maxRow && tempLength == minLength ){
280.                 
281.                 /*
282.                  * 设置最小行数
283.                  */
284.                 while(arr[minRow][tempLength] != 0 &
285.                         minRow < row -1){
286.                     minRow++;
287.                 }
288.                 
289.                 /*
290.                  * 从下向上这个方向填充数组
291.                  */
292.                 while(tempRow > minRow){
293.                     tempRow--;
294.                     i++;
295.                     arr[tempRow][tempLength] = i;
296.                 }
297.             }
298.         }
299.     }
300. }