一个JAVA程序题

Question

简单点,以4*4的数组为例:
//初始化数组
int[] data  = new int[4]{};
for(int i=0;i<row.size();i++)
{
   data[i] = new int[4]{};    
}
//初始化行.列标志 1为行填充,2为列填充
//初始化前进.后退标志,1为前进,2为后退
int rowColflag = 1;
int aheadBackFlag = 1;
int row=0,col=0;
for(int i=0;i<16;i++)
{
  //边界判断
  if(rowColflag==2&&aheadBackFlag==1)
  {
     //列填充变行填充1
     if(row==3||data[row+1][col]!=0)
     {
         rowColflag = 1; 
         if(col==0||data[row][col-1]!=0)
         {
            //行向前填充 
            aheadBackFlag = 1;
         }
         else
         {
            //行向后填充
            aheadBackFlag = 2;
         }        
     }
  }
  if(rowColflag==1&&aheadBackFlag==1)
  {
     //行填充变列填充1
     if(col==3||data[row][col+1]!=0)
     {
         rowColflag = 2; 
         if(col==3||data[row][col+1]!=0)
         {
           //列向后填充 
            aheadBackFlag = 2;
         }
         else
         {
            //列向前填充
            aheadBackFlag = 1;
         }        
     }
     
  }
  if(rowColflag==2&&aheadBackFlag==2)
  {
     //列填充变行填充2
     if(row==0||data[row-1][col]!=0)
     {
         rowColflag = 1; 
         if(col==3||data[row][col+1]!=0)
         {
           //列向后填充 
            aheadBackFlag = 2;
         }
         else
         {
            //列向前填充
            aheadBackFlag = 1;
         }        
     }  }
  if(rowColflag==1&&aheadBackFlag==2)
  {
     //行填充变列填充2
     if(col==0||data[row][col-1]!=0)
     {
         rowColflag = 1; 
         if(col==0||data[row+1][col]!=0)
         {
           //列向后填充 
            aheadBackFlag = 2;
         }
         else
         {
            //列向前填充
            aheadBackFlag = 1;
         }  
  }  data[row][col]=i+1;
  //向下填充
  if(rowColflag==2&&aheadBackFlag==1)
  {
      col++;
  }
  //向上填充 
  else if(rowColflag==2&&aheadBackFlag==2)
  {
      col--;
  }
  //向右填充
  else if(rowColflag==1&&aheadBackFlag==1)
  {
      row++;
  }
  //向左填充
  else if(rowColflag==1&&aheadBackFlag==2)
  {
      row--;
  }
  
}
想得不是很全,大致就是把各个边界条件都考虑到,然后就按方向填充即可

Answer 1

不懂大版主说的右深度遍历，自己琢磨了一个
public class LuoXuan1 {
private int index;
private int overNumber;
private int[][] arr; public LuoXuan1(int index) {
this.index = index;
overNumber = index*index+1;
arr = new int[index][index];
int i = 0, j = 0, displayNumber = 1;
for (int k = 0; k < index; k++) {
//从上往下纵向赋值
while (i < index-k && overNumber!=displayNumber) {
arr[i++][j] = displayNumber++;
}
//从上往下向右拐弯
i--;
j++;
//从左往右横向赋值
while (j < index-k && overNumber!=displayNumber) {
arr[i][j++] = displayNumber++;
}
//从左往右向上拐弯
j--;
i--;
//从下往上纵向赋值
while (i >= 0+k && overNumber!=displayNumber) {
arr[i--][j] = displayNumber++;
}
//从下网上向左拐弯
i++;
j--;
//从右往左横向赋值
while (j > 0+k && overNumber!=displayNumber) {
arr[i][j--] = displayNumber++;
}
//从右往左向下拐弯
j++;
i++;
}
for(i=0;i<index;i++){
for(j=0;j<index;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println("");
}
} public static void main(String[] args) {
new LuoXuan1(5);
}
}
后面那个和这个差不多

Answer 2

怎么我不能修改我自己的帖子呢，说我权限不够，其实后面那个就是吧前面那个倒过来输出而已，将我程序中的displayNumber初始大小改为index*index+1,然后吧所有displayName++改成displayNumber--就可以实现第2个螺旋了，输入4就是1-16，输入5就是1-25，以此类推

Answer 3

偶也不太懂，我按规律算...public class test{
  test(int x,int y){
    for(int i=0;i<x;i++)
      for(int j=0;j<y;j++){
        int u=i>x-i-1?x-i-1:i;
        int v=j>y-j-1?y-j-1:j;
        int layer=u>v?v:u;
        int base=0;
        int a=x-layer*2;
        int b=y-layer*2;
        int addition=j==layer?i-layer+1:i==x-layer-1?j-layer+a:j==y-layer-1?a*2+b-2-i+layer:a*2+b*2-3-j+layer;
        for(int m=(x+y-2)*2,n=layer;m>8&&n>0;m-=8,n--)
          base+=m;
        System.out.print(base+addition+(j==y-1?"\n":" "));
      }
  }
  public static void main(String args[]){
    new test(9,7);
  }
}
==================================
C:\java>java test
1 28 27 26 25 24 23
2 29 48 47 46 45 22
3 30 49 60 59 44 21
4 31 50 61 58 43 20
5 32 51 62 57 42 19
6 33 52 63 56 41 18
7 34 53 54 55 40 17
8 35 36 37 38 39 16
9 10 11 12 13 14 15

Answer 4

public class Test {
public static void main(String[] args){
int[][] testArray=f(12,8,36);
for(int i[]:testArray){
for(int j:i)
System.out.printf("%4d",j);
System.out.println();
}
}
static int[][]  f(int rowSize,int colSize,int initNum){
int[][] a=new int[rowSize][colSize];
int i=-1,j=-1,k=initNum;
int maxNum=rowSize*colSize+initNum;
int flag=-1;
while(k<maxNum){
flag++;
for(i++,j++;i<rowSize;i++){
a[i][j]=k++;
}
rowSize--;
for(i--,j++;j<colSize;j++){
a[i][j]=k++;
}
colSize--;
for(j--,i--;i>flag-1;i--){
a[i][j]=k++;
}
for(i++,j--;j>flag;j--){
a[i][j]=k++;
}
}
return a;
}
}
output:
  36  71  70  69  68  67  66  65
  37  72  99  98  97  96  95  64
  38  73 100 119 118 117  94  63
  39  74 101 120 131 116  93  62
  40  75 102 121 130 115  92  61
  41  76 103 122 129 114  91  60
  42  77 104 123 128 113  90  59
  43  78 105 124 127 112  89  58
  44  79 106 125 126 111  88  57
  45  80 107 108 109 110  87  56
  46  81  82  83  84  85  86  55
  47  48  49  50  51  52  53  54