黑马程序员技术交流社区

标题: 如何将此代码优化成任意长宽的排列 [打印本页]
作者: 清风有意    时间: 2014-4-10 15:09
标题: 如何将此代码优化成任意长宽的排列
本人写的正方形代码如下：

  1. package cn.itheima.exam;
  2. /**
  3. * 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：     
  4. *        1        2        3        4
  5. *        12        13        14        5
  6. *        11        16        15        6
  7. *        10        9        8        7
  8. */
  9. public class Test9 {

  11.         public static void main(String[] args) {
  12.                 int[][] arr=new int[9][9];
  13.                 circleArr(arr);
  14.                 for(int x=0;x<arr.length;x++)
  15.                 {
  16.                         for(int y=0;y<arr[0].length;y++)
  17.                         {
  18.                                 System.out.print(arr[x][y]+"  \t  ");
  19.                                
  20.                         }
  21.                         System.out.println();
  22.                 }
  23.        
  24.         }

  26.         private static void circleArr(int[][] arr) {
  27.                 int x=0,y=0;
  28.                 int max=arr.length-1;
  29.                 int min=0;
  30.                 int z=0;
  31.                 for(;max>=min;){
  32.                
  33.                         for(;y<max;y++){       
  34.                                 z++;
  35.                         arr[x][y]=z;
  36.                         }
  37.                        
  38.                         for(;x<max;x++)
  39.                         {        z++;
  40.                                 arr[x][y]=z;
  41.                         }
  42.                        
  43.                         for(;y>min;y--)
  44.                         {        z++;
  45.                                 arr[x][y]=z;
  46.                         }
  47.                         for(;x>min;x--)
  48.                         {
  49.                                 z++;
  50.                                 arr[x][y]=z;
  51.                         }
  52.                         if(max==min)
  53.                         {
  54.                                 arr[x][y]=++z;
  55.                         }
  56.                         x++;
  57.                         y++;
  58.                         max--;
  59.                         min++;
  60.                 }
  61.         }

  63. }
复制代码
作者: ehuashao    时间: 2014-4-11 09:55
用类似树的深度搜索，走完一步，去搜索可走的下一步。注释很详细，不详解了。
  1. public class Test99 {

  3.         public static void main(String[] args) {
  4.                 Test99 test = new Test99();
  5.                 //从键盘接收一个数，动态确定数组大小
  6.                 System.out.println("请输入一个数，来作为您的二位数组长度：");
  7.                 Scanner sc = new Scanner(System.in);
  8.                 int chang = sc.nextInt();
  9.                 System.out.println("请输入一个数，来作为您的二位数组宽度：");
  10.                 int kuan = sc.nextInt();
  11.                 int[][] arr = new int[chang][kuan];
  12.                 //数组初始值都设置为0，代表每一位还没有被访问过。
  13.                 for(int i=0;i<chang;i++){
  14.                         for(int j=0;j<kuan;j++)
  15.                                 arr[i][j] = 0;
  16.                 }
  17.                
  18.                 /*观察得数字运动路线为：右，下，左，上。所有定义变量来记录上一个数字运动方向。
  19.                   右：1  下：2  左：3 上：4 .第一步肯定往右，所有move初始值为1.
  20.                  */
  21.                 int move =1;
  22.                 int step =0;//记录步数
  23.                 int i=0,j=0;//初始位置
  24.        
  25.                 while(step < chang*kuan){
  26.                         move = test.printArr(arr, i, j, move, chang,kuan);
  27.                         switch(move){
  28.                                 case 1:
  29.                                         arr[i][j++] = ++step;                               
  30.                                         break;
  31.                                 case 2:
  32.                                         arr[i++][j] = ++step;                               
  33.                                         break;
  34.                                 case 3:
  35.                                         arr[i][j--] = ++step;                               
  36.                                         break;
  37.                                 case 4:
  38.                                         arr[i--][j] = ++step;                               
  39.                                         break;
  40.                                 case -1:
  41.                                         break;
  42.                         }
  43.                 }
  44.        
  45.                 //输出数组
  46.                 for(int m=0;m<chang;m++){
  47.                         for(int n=0;n<kuan;n++){
  48.                                 System.out.print(arr[m][n]+"   ");
  49.                         }               
  50.                         System.out.println("");
  51.                 }
  52.         }
  53.        
  54.         //根据上一步的运动，以及边界条件来判断下一步该往哪个方向运动
  55.         public int printArr(int[][]arr,int i,int j,int move,int chang,int kuan){
  56.                 //如果上一步是向右走，则判断该位置右侧是否已被访问或已达边界，是返回2，指示下一步向下走，否则返回1继续向右走
  57.                 if(move == 1){
  58.                         if((j+1)>=kuan || arr[i][j+1] !=0){
  59.                                 return 2;
  60.                         }
  61.                         else return 1;
  62.                 }
  63.                 //如果上一步向下走，则判断该位置下面位置是否已被访问或已达边界，是返回3，指示下一步向左走，否返回2继续下走。
  64.                 else if(move == 2){
  65.                         if((i+1)>=chang || arr[i+1][j] != 0){
  66.                                 return 3;
  67.                         }
  68.                         else return 2;
  69.                 }
  70.                 //如果上一步向左走，则判断该位置左侧位置是否已被访问或已达边界，是返回4，指示下一步向上走，否返回3继续左走。
  71.                 else if(move == 3){
  72.                         if(j<=0 || arr[i][j-1] != 0){
  73.                                 return 4;
  74.                         }
  75.                         else return 3;
  76.                 }
  77.                 //如果上一步向上走，则判断该位置上面位置是否已被访问或已达边界，是返回1，指示下一步向右走，否返回4继续向上走。
  78.                 else if(move == 4){
  79.                         if(i<=0 || arr[i-1][j] != 0){
  80.                                 return 1;
  81.                         }
  82.                         else return 4;
  83.                 }
  84.                 return -1;
  85.                
  86.         }
  87. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2