用户输入一个数 就能打印出这个数的方阵
例如 用户输入4 打印结果就是
1      2      3      4
12    13    14    5
11    16    15    6
10     9       8    7
用递归和二维数组实现。

public class ScrewSquares {

    public static void main(String[] args) {
        int w =4;
        int h =4;
        int[][] array = new int[w][h];
        fill(array, 0, 0, w-1, h-1, 1);
        for (int y=0; y<h; y++) {
            for (int x=0; x<w; x++) {
                System.out.printf("%2d ", array[x][y]);
            }
            System.out.println();
        }
    }

    public static void fill(int[][] array, int left, int top, int right, int bottom, int start) {
        if (left > right || top > bottom) return;

        for (int x=left; x<=right; x++)
            array[x][top] = start++;

        for (int y=top+1; y<=bottom; y++)
            array[right][y] = start++;

        for (int x=right-1; x>=left; x--)
            array[x][bottom] = start++;

        for (int y=bottom-1; y>=top+1; y--)
            array[left][y] = start++;

        fill(array, left+1, top+1, right-1, bottom-1, start);//递归调用
    }
}

public class FillArray {

        private int[][] array ;
        private int max ;
        private int currentNum;
        
        public FillArray(int len){
                this.array = new int[len][len];
                this.max = len*len;
        }
        
        public void fill(int i,int j){
                // 若数组还没有填充完毕。
                if(this.currentNum<this.max){
                        // 从左到右填充。
                        for(;j<this.array.length && this.array[j]==0;j++){
                                this.array[j]= ++this.currentNum;
                        }
                        // 调整位置。
                        i++ ;  j--;
                        // 从上到下填充。
                        for(;i<this.array.length && this.array[j]==0;i++){
                                this.array[j] = ++this.currentNum;
                        }
                        // 调整位置。
                        i--;  j--;
                        // 从右到左填充。
                        for(;j>=0 && this.array[j]==0;j--){
                                this.array[j] = ++this.currentNum;
                        }
                        // 调整位置。
                        j++;  i--;
                        // 从下到上填充。
                        for(;i>=0&&this.array[j] ==0;i--){
                                this.array[j] = ++this.currentNum;
                        }
                        // 调整位置。
                        i++;  j++;
                        
                        // 递归填充。
                        this.fill(i, j);
                }
        }
        public static void main(String[] args) {
                FillArray obj = new FillArray(6);
                obj.fill(0, 0);
                int[][] array = obj.array;
                for(int[] row:array){
                        for(int col:row){
                                System.out.print(col+" ");
                        }
                        System.out.println();
                }
        }
}

1. public class FillArray {
   
2. 
   
3.         private int[][] array ;
   
4.         private int max ;
   
5.         private int currentNum;
   
6.         
   
7.         public FillArray(int len){
   
8.                 this.array = new int[len][len];
   
9.                 this.max = len*len;
   
10.         }
    
11.         
    
12.         public void fill(int i,int j){
    
13.                 // 若数组还没有填充完毕。
    
14.                 if(this.currentNum<this.max){
    
15.                         // 从左到右填充。
    
16.                         for(;j<this.array.length && this.array[i][j]==0;j++){
    
17.                                 this.array[i][j]= ++this.currentNum;
    
18.                         }
    
19.                         // 调整位置。
    
20.                         i++ ;  j--;
    
21.                         // 从上到下填充。
    
22.                         for(;i<this.array.length && this.array[i][j]==0;i++){
    
23.                                 this.array[i][j] = ++this.currentNum;
    
24.                         }
    
25.                         // 调整位置。
    
26.                         i--;  j--;
    
27.                         // 从右到左填充。
    
28.                         for(;j>=0 && this.array[i][j]==0;j--){
    
29.                                 this.array[i][j] = ++this.currentNum;
    
30.                         }
    
31.                         // 调整位置。
    
32.                         j++;  i--;
    
33.                         // 从下到上填充。
    
34.                         for(;i>=0&&this.array[i][j] ==0;i--){
    
35.                                 this.array[i][j] = ++this.currentNum;
    
36.                         }
    
37.                         // 调整位置。
    
38.                         i++;  j++;
    
39.                         
    
40.                         // 递归填充。
    
41.                         this.fill(i, j);
    
42.                 }
    
43.         }
    
44.         public static void main(String[] args) {
    
45.                 FillArray obj = new FillArray(6);
    
46.                 obj.fill(0, 0);
    
47.                 int[][] array = obj.array;
    
48.                 for(int[] row:array){
    
49.                         for(int col:row){
    
50.                                 System.out.print(col+" ");
    
51.                         }
    
52.                         System.out.println();
    
53.                 }
    
54.         }
    
55. }

复制代码

只要还是递归。这个方阵看起来是一个 回 字。 所以先遍历外面的一圈口  然后再递归里面的几圈口。
这个感觉还是有点面对过程。谁能用面对对象把代码简化一下。