A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© せR3n、何必装纯 黑马帝   /  2011-11-22 15:02  /  1612 人查看  /  3 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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

3 个回复

倒序浏览
本帖最后由 肖瑞军 于 2011-11-22 16:03 编辑

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);//递归调用
    }
}

评分

参与人数 1技术分 +2 收起 理由
老罗 + 2

查看全部评分

回复 使用道具 举报
本帖最后由 袁世宇 于 2011-11-22 16:28 编辑

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技术分 +2 收起 理由
老罗 + 2

查看全部评分

回复 使用道具 举报
本帖最后由 袁世宇 于 2011-11-22 16:27 编辑
  1. public class FillArray {

  2.         private int[][] array ;
  3.         private int max ;
  4.         private int currentNum;
  5.         
  6.         public FillArray(int len){
  7.                 this.array = new int[len][len];
  8.                 this.max = len*len;
  9.         }
  10.         
  11.         public void fill(int i,int j){
  12.                 // 若数组还没有填充完毕。
  13.                 if(this.currentNum<this.max){
  14.                         // 从左到右填充。
  15.                         for(;j<this.array.length && this.array[i][j]==0;j++){
  16.                                 this.array[i][j]= ++this.currentNum;
  17.                         }
  18.                         // 调整位置。
  19.                         i++ ;  j--;
  20.                         // 从上到下填充。
  21.                         for(;i<this.array.length && this.array[i][j]==0;i++){
  22.                                 this.array[i][j] = ++this.currentNum;
  23.                         }
  24.                         // 调整位置。
  25.                         i--;  j--;
  26.                         // 从右到左填充。
  27.                         for(;j>=0 && this.array[i][j]==0;j--){
  28.                                 this.array[i][j] = ++this.currentNum;
  29.                         }
  30.                         // 调整位置。
  31.                         j++;  i--;
  32.                         // 从下到上填充。
  33.                         for(;i>=0&&this.array[i][j] ==0;i--){
  34.                                 this.array[i][j] = ++this.currentNum;
  35.                         }
  36.                         // 调整位置。
  37.                         i++;  j++;
  38.                         
  39.                         // 递归填充。
  40.                         this.fill(i, j);
  41.                 }
  42.         }
  43.         public static void main(String[] args) {
  44.                 FillArray obj = new FillArray(6);
  45.                 obj.fill(0, 0);
  46.                 int[][] array = obj.array;
  47.                 for(int[] row:array){
  48.                         for(int col:row){
  49.                                 System.out.print(col+" ");
  50.                         }
  51.                         System.out.println();
  52.                 }
  53.         }
  54. }
复制代码
只要还是递归。这个方阵看起来是一个 回 字。 所以先遍历外面的一圈口  然后再递归里面的几圈口。
这个感觉还是有点面对过程。谁能用面对对象把代码简化一下。

评分

参与人数 1技术分 +2 收起 理由
老罗 + 2

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马