输出 n=5 的螺旋方阵
        1  2  3  4  5
        16 17 18 19 6
        15 24 25 20 7
        14 23 22 21 8
        13 12 11 10 9

前两天的笔试题，你看看吧，应该对你有帮助。
/*
*  写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：     
* 示例
*         1        2        3        4
*
*        12        13        14        5
*
*        11        16        15        6
*
*        10        9        8        7
*思路：1.给二维数组复制肯定使用循环
*    2.找规律，然后循环
*    3.每一圈为一次大循环，然后四个边各遵循一个规律，总结归路
*    4.打印
*/
public class Test9 {

        public static void main(String[] args) {

                int n = 6;
                int count = 1;
                int[][] arr = new int[n][n];

                // 循环圈数，以大圈为准，大圈规律，开始数组角标x=y=z;z表示第z-1圈
                for (int z = 0; z < (n + 1) / 2; z++) {

                        // 上横排规律，x不变，y自增
                        for (int x = z, y = z; y < n - z - 1; y++) {
                                arr[x][y] = count++;
                        }
                       
                        // 右竖排，y不变，x自增
                        for (int x = z, y = n - z - 1; x < n - z - 1; x++) {
                                arr[x][y] = count++;
                        }
                       
                        // 下横排，x不变，y自减
                        for (int x = n - z - 1, y = x; y >= z; y--) {
                                arr[x][y] = count++;
                        }
                       
                        // 右竖排，y不变，x自减
                        for (int x = n - z - 2, y = z; x > z; x--) {
                                arr[x][y] = count++;
                        }
                }
               
                // 打印
                for (int i = 0; i < n; i++) {
                        for (int j = 0; j < n; j++) {
                                System.out.print("        " + arr[i][j]);
                        }
                        System.out.println();
                        System.out.println();
                }
        }
}

顶个帖子

import java.util.Scanner;
class Demo
{
public static void main(String[] args) {
  int size=5;
  Scanner sc=new Scanner(System.in);
  System.out.println("输入数组大小:");
  size=sc.nextInt();
  
  int count=0;  
  int [][]array=new int[size][size];
  int m=0,n=0;
  int down,right,up=0,left=0;
  down=size-1;
  right=size-1;
  int max=size*size;
  while(true){
   count++;
   if(m==up){
    array[m][n]=count;
    n++;
    if(n>right){
     n=right;
     m++;
    }
   }
   else if(n==right){
    array[m][n]=count;
    m++;
    if(m>down){
     m=down;
     right--;
    }
   }
   else if(m==down){
    array[m][right]=count;
    right--;
    if(right<left){
     right=left;
     down--;
    }
   }
   else if(right==left){
    array[down][left]=count;
    down--;
    if(down<=up){
     down=up;
     left++;
    }
   }
   else{
           up++;
           down=n-1;
           right=m-1;
           m=up;
           n=left;
           count--;
   }
   
         if(count>=max){
                break;
                }
  }// end loop
  for (int i = 0; i < size; i++) {
   for (int j = 0; j < size; j++) {
    System.out.print(array[i][j]+"\t");
                        }
        System.out.println();
        }
   }
}

这面试题好难啊，对于我这新手来说基本没戏

马克一下.....

大自然的搬运工 发表于 2015-11-6 00:04
前两天的笔试题，你看看吧，应该对你有帮助。
/*
*  写一方法，打印等长的二维数组，要求从1开始的自然数 ...

解答不错，有没有更好的算法啊。

这个题目很经典啊

main()
{void build_array(int a[],int m,int n);
int a[15][15]={0};
int m,n;
printf("please input the fac nuuber of the uatrix m and n:(1~15):");
scanf("%d,%d",&m,&n);
build_array(a,m,n);
}
void build_array(int a[],int m,int n)
{int i,j,k=0,u=0;
do
{
for(j=u,i=u;i<m-u;i++)
{k++;
a[i*n+j]=k;
}
for(i=m-u-1,j=u+1;j<n-u;j++)
{k++;
a[i*n+j]=k;
}
for(j=n-u-1,i=m-u-2;i>=u;i--)
{k++;
a[i*n+j]=k;
}
for(i=u,j=m-u-2;j>u;j--)
{k++;
a[i*n+j]=k;
}
u++;
}while(u<=(m+n+1)/2);
printf("\nThe uatrix is:\n");
for(i=0;i<m;i++)
{for(j=0;j<n;j++)
printf("%4d",a[i*n+j]);
printf("\n");
}
}

挺有意思的题啊

1. import java.util.Scanner;
   
2. public class SpiralMatrix {
   
3.         public static void main(String [] args){
   
4.                 Scanner scn= new Scanner(System.in);
   
5.                 System.out.println("请输入螺旋方阵的阶数: ");
   
6.                 int order=scn.nextInt();
   
7.                
   
8.                 SpiralMatrix sm=new SpiralMatrix();
   
9.                 sm.printClockWise(order);
   
10.         }
    
11.         //找到一个函数能够计算出order阶矩阵中  row 行, col列上的数值大小, 想到递归
    
12.         public int getValue(int row, int col, int order) {
    
13.                 //基准条件
    
14.                 if(1==order)      //最简单的一阶
    
15.                         return order;
    
16.                 if(0==order)      //偶数阶的最简单形式
    
17.                         return order;
    
18.                
    
19.                 // 高阶矩阵而元素又位于矩阵的最外层, 能够通过简单的计算得出.
    
20.                 //由于涉及多个 return语句, 只用if即可 .
    
21.                 if(0==row)
    
22.                         return col+1;
    
23.                 if (col==order-1)
    
24.                         return col+row+1;
    
25.                 if(row==order-1)
    
26.                         return 3*order-2-col;
    
27.                 if(0==col)
    
28.                         return 4*order-3-row;
    
29.                 //所有简单的情况排除后,进行脱阶运算.
    
30.                 return (order*4-4)+getValue(row-1, col-1, order-2);
    
31.         }
    
32.         public void  printClockWise(int order) {
    
33.                 int value;
    
34.                 for(int i=0;i<order; i++) {
    
35.                         for(int j=0;j<order; j++) {
    
36.                                 value=getValue(i,j,order);
    
37.                                 System.out.print(value+"\t");
    
38.                         }
    
39.                         System.out.println();
    
40.                 }
    
41.         }
    
42. }
    

复制代码

1. 
   
2. /*
   
3. 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：     
   
4. */
   
5. class Test8
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 printArray(10);
   
10. 
    
11.                 System.out.println("Hello World!");
    
12.         }
    
13.         public static void printArray(int len){
    
14.                
    
15.                 //定义递增
    
16.                 int val=1;
    
17.                 //定义二维数组
    
18.                 int[][] it=new int[len][len];
    
19.                 //定义循环次数，如果为偶数，则循环测试为长度的一般，如果为奇数，则为长度-1的一半
    
20.                 int count=len%2==0? len/2:(len-1)/2;
    
21.                 for(int x=0;x<count;x++){
    
22.                         //定义口子上面的数字顺序
    
23.                         for(int i=x,j=i;j<len-x;j++){
    
24.                                 it[i][j]=val++;
    
25.                                        
    
26.                         }
    
27.                         //定义右面的数字顺序
    
28.                         for(int j=len-x-1,i=x+1;i<len-x;i++){
    
29.                                 it[i][j]=val++;
    
30.                         }
    
31.                         //定义下面的数字顺序
    
32.                         for(int i=len-x-1,j=len-x-2;j>x-1;j--){
    
33.                                 it[i][j]=val++;
    
34.                         }
    
35.                         //定义左面的数字顺序
    
36.                         for(int j=x,i=len-x-2;i>x;i--){
    
37.                                 it[i][j]=val++;
    
38.                         }
    
39.                
    
40.                 }
    
41.                 if(len%2==1){
    
42.                         it[(len-1)/2][(len-1)/2]=val++;
    
43.                 }
    
44.                 for(int m=0;m<len;m++){
    
45.                         for(int n=0;n<len;n++){
    
46.                                 System.out.print(it[m][n]+"\t");
    
47.                         }
    
48.                         System.out.println();
    
49.                 }
    
50.         }
    
51. }
    

复制代码

学习一下

算法有很多种，反正第一行是打印1.。。。。n，n为奇数，最大数在n+1/2行n+1/2列，为偶数就在n/2+1行n/2列，最大数为n的平方，说白了就是以正方形遍历1.。。。。n*n找出规律总结出来

import java.util.Scanner;

public class Helix {

/**
  * 螺旋输
  */
public static void main(String[] args) {
  int size=5;
  Scanner sc=new Scanner(System.in);
  System.out.println("输入数组:");
  size=sc.nextInt();
  
  int count=0;  
  int [][]array=new int[size][size];
  int m=0,n=0;
  int down,right,up=0,left=0;
  down=size-1;
  right=size-1;
  int max=size*size;
  while(true){
   count++;
   if(m==up){
    array[m][n]=count;
    n++;
    if(n>right){
     n=right;
     m++;
    }
   }
   else if(n==right){
    array[m][n]=count;
    m++;
    if(m>down){
     m=down;
     right--;
    }
   }
   else if(m==down){
    array[m][right]=count;
    right--;
    if(right<left){
     right=left;
     down--;
    }
   }
   else if(right==left){
    array[down][left]=count;
    down--;
    if(down<=up){
     down=up;
     left++;
    }
   }
   else{
   up++;
   down=n-1;
   right=m-1;
   m=up;
   n=left;
   count--;
   }
   /////////////////////////////////////////////
   if(count>=max){
    break;
   }
  }// end loop
  for (int i = 0; i < size; i++) {
   for (int j = 0; j < size; j++) {
    System.out.print(array[i][j]+"\t");
   }
   System.out.println();
  }
   }
}

import java.util.Scanner;

public class Helix {

/**
  * 螺旋输出
  */
public static void main(String[] args) {
  int size=5;
  Scanner sc=new Scanner(System.in);
  System.out.println("输入数组大小:");
  size=sc.nextInt();
  
  int count=0;  
  int [][]array=new int[size][size];
  int m=0,n=0;
  int down,right,up=0,left=0;
  down=size-1;
  right=size-1;
  int max=size*size;
  while(true){
   count++;
   if(m==up){
    array[m][n]=count;
    n++;
    if(n>right){
     n=right;
     m++;
    }
   }
   else if(n==right){
    array[m][n]=count;
    m++;
    if(m>down){
     m=down;
     right--;
    }
   }
   else if(m==down){
    array[m][right]=count;
    right--;
    if(right<left){
     right=left;
     down--;
    }
   }
   else if(right==left){
    array[down][left]=count;
    down--;
    if(down<=up){
     down=up;
     left++;
    }
   }
   else{
   up++;
   down=n-1;
   right=m-1;
   m=up;
   n=left;
   count--;
   }
   /////////////////////////////////////////////
   if(count>=max){
    break;
   }
  }// end loop
  for (int i = 0; i < size; i++) {
   for (int j = 0; j < size; j++) {
    System.out.print(array[i][j]+"\t");
   }
   System.out.println();
  }
   }
}

顶一个哈哈哈

我就看看 跟大神学习一下