写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
* 如： n = 4 则打印
*  1  2   3   4
* 12 13 14 5
* 11 16 15 6
* 10  9  8   7
谁有思路的附上代码，有思路更好。

这不是入学考试的面试题吗？

1. import java.io.*;
   
2. 
   
3. class  roll
   
4. {         
   
5.         public static void main(String[] args) throws Exception
   
6.         {
   
7.                 BufferedReader bufr=
   
8.                         new BufferedReader(new InputStreamReader(System.in));
   
9.                 int buf=new Integer(bufr.readLine());
   
10. 
    
11.                 int[][] arr=new int[20][20];
    
12.                 System.out.println("buf="+buf);
    
13.                 int row1=1,col1=1;
    
14.                 int i=1,j=1,k=1;
    
15.                 int row,col;
    
16.                 row=col=buf;
    
17.                 do{
    
18.                         for(;i<row;i++)
    
19.                         arr[j-1][i-1]=k++;
    
20.                         row--;
    
21.                         for(;j<col;j++)
    
22.                         arr[j-1][i-1]=k++;
    
23.                         col--;
    
24.                         for(;i>col1;i--)
    
25.                         arr[j-1][i-1]=k++;
    
26.                         col1++;
    
27.                         for(;j>row1;j--)
    
28.                         arr[j-1][i-1]=k++;
    
29.                         row1++;
    
30.                         i++;j++;
    
31.                 }while(row1<row&&col1<col);
    
32.                 arr[i-1][j-1]=k;
    
33.                 for(i=0;i<buf;i++){
    
34.                         for(j=0;j<buf;j++)
    
35.                         {
    
36.                         System.out.print(arr[i][j]+"\t");
    
37.                         }
    
38.                         System.out.println();
    
39.                         }
    
40.         }
    
41. }
    

复制代码

要思路就回复我.

1. /**
   
2. * 思路:把一个矩阵看做是一个个正方形套在一起，由最外边的那个正方形开始去赋值。因为这个赋值的过程是
   
3. * 重复去操作，而且正方形的个数如果不是很多，可以考虑递归。正方形的个数（len/2）（其中len是矩阵的
   
4. * 边长）。在遍历的每一个正方形的起点的位置就是上一个正方形终点的列值加1，起点的值就是上一个正方形
   
5. * 终点的值加1.
   
6. *
   
7. * 注：代码里可以指定矩阵的边长的，不一定要是正方形矩阵，也可以是长方形矩阵（思路里是真的正方形写的，
   
8. * 长方形可他其实是一样的）。
   
9. */
   
10. public class Test2 {
    
11.         public static int[][] array = new int[10][10];
    
12. 
    
13.         public static void main(String[] args) {
    
14.                 int x_len = 5;
    
15.                 int y_len = 7;
    
16.                 putValues(x_len,y_len, 0, 0, 1);
    
17.                 printlnArray(x_len,y_len);
    
18.         }
    
19. 
    
20.         public static void putValues(int x_len,int y_len, int x, int y, int first_value) {
    
21.                 //如果边长为1，说明就一个值，直接赋值即可，然后return出去（递归的出口）
    
22.                 if (x_len == 1) {
    
23.                         for(int i=0;i<y_len;i++){
    
24.                                 array[x][y++] = first_value++;
    
25.                         }
    
26.                         return;
    
27.                 }
    
28.                 array[x][y] = first_value;
    
29.                 //上，右，下，左 循环给数组赋值（这样的顺序是因为值都是在累加的）
    
30.                 for (int j = 0; j < y_len-1; j++) {
    
31.                         array[x][++y] = ++first_value;
    
32.                 }
    
33.                 for (int j = 0; j < x_len-1; j++) {
    
34.                         array[++x][y] = ++first_value;
    
35.                 }
    
36.                 for (int j = 0; j < y_len-1; j++) {
    
37.                         array[x][--y] = ++first_value;
    
38.                 }
    
39.                 for (int j = 0; j < x_len-2; j++) {
    
40.                         array[--x][y] = ++first_value;
    
41.                 }
    
42.                 //判断矩阵的变长是否>=1(如果是，继续给内部的方形赋值)递归
    
43.                 if(x_len -2>=1){
    
44.                         putValues(x_len - 2,y_len-2, x, ++y, ++first_value);
    
45.                 }
    
46.                
    
47.         }
    
48. 
    
49.         public static void printlnArray(int x_len,int y_len) {
    
50.                 for (int i = 0; i < x_len; i++) {
    
51.                         System.out.print("*");
    
52.                         for (int j = 0; j < y_len; j++) {
    
53.                                 System.out.print(array[i][j] + " ");
    
54.                         }
    
55.                         System.out.println("");
    
56.                 }
    
57.         }
    
58. }
    

复制代码

对长方形矩阵可以满足螺旋打印。。。{:soso_e100:}

这个题我也有

@乔兵，这是入学测试题啊，可以这么问的？还给加分？

张俊生 发表于 2013-10-8 20:03
这个题我也有

想了半天才写完，:(，有难度这题

ｊìｎｇ╮煜 发表于 2013-10-8 14:01

为什么这个代码在运行时输入n=4时，该出现数字15的位置反而出现17呢，而n=5时，输出就正确了，不解？？？

public class Test9 {
  public static void main(String[] args){
   //定义数组的长度
   
    int len = 10;
   
    //调用得到螺旋数组的方法
   
   int[][] arys = getSpiralArray(len);
   
    //用for循环嵌套，对数组进行遍历输出
   
    for (int i = 0; i < len; i++)
     {
      for (int j = 0; j < len; j++)
      {  
   
       System.out.print(arys[i][j] + "\t");
      }
        System.out.println();
    }
  }

public static int[][] getSpiralArray(int length) {
  //定义一个等长度的数组
  
  int[][] array = new int[length][length];
  
  int upcol = 0;
  
  //向右走列数
  
  int leftRow = 0;
  
  //记录最后一行的变量
  
  int downCol = length-1;
  
  //记录最后一列的变量
  
  int rightRow = length-1;
  
  int num = 1;
  while(length > 0){
   
   //向右走，循环遍历，并把得到的值添加到数组中
   
   for(int i = 0, temp = leftRow; i < length; i++){
   
    //第一行，打印向右走，随着列数的的自增1，第一行的元素也随着自增1
   
    array[upcol][temp++] = num++;      
   }     
   //向下走，循环遍历，并把得到的值添加到数组中
   
   for(int i = 0, temp =  leftRow+1; i < length-1; i++){
   
    //最后一列，打印向下走，随着行数的自增1，最后一列的元素也自增1
   
    array[temp++][downCol] = num++;
   }
   
   //向左走，循环遍历，并把得到的值添加到数组中,是从length-1列的最后一个元素开始，所以是rightRow-1
   
   for(int i = 0, temp = rightRow-1; i < length-1; i++){
   
    //最后一行，打印向左走，随着列数的自减1，最底层的元素自增1
   
    array[downCol][temp--] = num++;
   }   
   //向上走，循环遍历，并把得到的值添加到数组中  ,是从length-1行的最后一个元素开始，所以是downCol-1
   
   for(int i = 0, temp =downCol-1; i< length-2; i++){
   
    //最左边一列，向上打印，随着行数的自减1，最左边的一列中的元素自增1
   
    array[temp--][upcol] = num++;
   }
   //再往里边依次循环，直到打印到最后的一个数就是length的平方
   
   //每打印最外面的一圈，内圈的长度减少2
   
   length = length - 2;
   
   //向右走的行数增加1，也就是说第二轮循环是从第二行、第二列、length-1行、length-1列
   upcol++;
   leftRow++;
   downCol--;
   rightRow--;
  }  
  return array;
}  

}

/*
* 本题要求顺时针旋转，即考查方向问题
* 题目的方向路径：L->R,U->D,R->L,D->U
* 需注意：1.水平方向运动，行标不变；垂直方向运动，列表不变
*         2.转角处，注意变化，主要是缩距
*         3.二维整型数组求长度
* Created by Ian Feyman
* */
//按水平方向和垂直方向坐标分析

按照这个思路，代码量少