分享入学测试题 , 不知道代码还能不能再优化,或者有没其他简单方法 :

1. /*
   
2. 1、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：                                
   
3. 1        2        3        4
   
4. 12        13        14        5
   
5. 11        16        15        6
   
6. 10        9        8        7
   
7. 思路和步骤:
   
8.         1:利用二维数组 列为里面的一维数组
   
9.         2:给元素赋值 依题意可知方阵开始走动,必然有一边是被堵住 而且纵横交替因此 定义两个方法 一个横向一个纵向
   
10.           横向:左右都走一遍 而后转入纵向 如此循环 利用最大元素值n的平方来控制跳出循环
    
11.         3:跳出循环时必然赋值完毕,打印二维数组.
    
12. */
    
13. class Exam1
    
14. {        
    
15.         private static String insert = "";
    
16.         public static void main(String[] args)
    
17.         {
    
18.                 test(4);
    
19.         }        
    
20.                 //横向赋值的时候 必然有一边是被堵的
    
21.         public static void setX(int[][] arr,int x,int y,int count)
    
22.         {
    
23.                 if(arr[x][y]==arr.length*arr.length)//如果走到头了就退出
    
24.                         return;
    
25.                 if((x+1)<arr.length)//向右边走
    
26.                 {
    
27.                         while(arr[x+1][y]==0)
    
28.                         {
    
29.                                 arr[x+1][y] = count++;
    
30.                                 x++;
    
31.                                 if((x+1)>=arr.length)
    
32.                                         break;
    
33.                         }
    
34.                 }
    
35.                 if((x-1)>=0)//向左走
    
36.                 {
    
37.                         while(arr[x-1][y]==0)
    
38.                         {
    
39.                                 arr[x-1][y] = count++;
    
40.                                 x--;
    
41.                                 if((x-1)<0)
    
42.                                 break;
    
43.                         }
    
44.                 }
    
45.                 setY(arr,x,y,count);//调用纵向方法
    
46.         }
    
47.                 public static void setY(int[][] arr,int x,int y,int count)
    
48.         {
    
49.                 if((y+1)<arr[x].length)//直接向下走
    
50.                 {
    
51.                         while(arr[x][y+1]==0)
    
52.                         {
    
53.                                 arr[x][y+1] = count++;
    
54.                                 y++;
    
55.                                 if((y+1)>=arr[x].length)
    
56.                                         break;
    
57.                         }
    
58.                 }
    
59.                 if((y-1)>=0)//向上走
    
60.                 {
    
61.                         while(arr[x][y-1]==0)
    
62.                         {
    
63.                                 arr[x][y-1] = count++;
    
64.                                 y--;
    
65.                                 if((y-1)<0)
    
66.                                         break;
    
67.                         }
    
68.                 }
    
69.                 setX(arr,x,y,count);//调用横向方法
    
70.         }
    
71.         
    
72.         public static void test(int n)
    
73.         {
    
74.                 int[][] arr = new int[n][n];//初始化二维数组
    
75.                 arr[0][0] = 1;//给第一个元素赋值(因为set方法中是从第二个元素开始赋值)
    
76.                 setX(arr,0,0,2);//从x=0,y=0位置开始,第二个元素开始赋值,所以count传入2.
    
77.                 printArr(arr);//打印数组
    
78.         }
    
79. 
    
80.         public static void printArr(int[][] arr)
    
81.         {
    
82.                 for (int x=0;x<arr[0].length ;x++ )//遍历打印二维数组
    
83.                 {
    
84.                         for (int y=0;y<arr.length ;y++ )
    
85.                         {
    
86.                                 System.out.print(blank(arr,arr[y][x])+arr[y][x]+" ");//打印插入空格后的元素
    
87.                                 insert = "";
    
88.                         }
    
89.                         System.out.println("");//打印所有第二维某一行后,换行.
    
90.                 }
    
91.         }
    
92. 
    
93.         public static String blank(int[][] arr,int value)//传入当前数组和当前元素值,返回该插入的空格.
    
94.         {
    
95.                         int len = (arr.length*arr.length+"").length();//得到该数组最大值该有的长度
    
96.                         len = len - (value+"").length();//得到该插入的空格数
    
97.                         while (len>=0)//添加空格
    
98.                         {
    
99.                                 insert = insert+" ";
    
100.                                 len--;
     
101.                         }
     
102.                         return insert;
     
103.         }
     
104. }

复制代码

1. import java.util.Scanner;
   
2. public class Test9 {
   
3. public static void main(String[] args) {  
   
4.         
   
5.         System.out.println("请输入一个数，来作为您的二位数组维度：");//从键盘接收一个数，动态确定数组大小   
   
6.         Scanner sc = new Scanner(System.in);  
   
7.         int num = sc.nextInt();
   
8.         printArray(num);
   
9. }
   
10.         public static void printArray(int num){
    
11.                
    
12.                 int[][] arr = new int[num][num];//根据输入的值，初始化一个num阶的数组，数组里的元素都初始化为0
    
13.                 for(int i=0;i<num;i++){  
    
14.                         for(int j=0;j<num;j++)  
    
15.                         arr[i][j] = 0;  
    
16.                 }  
    
17.                 int cycles = num/2+num%2;//循环的总圈数
    
18.                 int count = 1;//圈数计数器
    
19.                 int step = 1;//初始化数字
    
20.                 while(count<=cycles){
    
21.                         int min = count-1;//最小坐标
    
22.                         int max = num-count;//最大坐标
    
23.                         if(min==max){
    
24.                                 arr[cycles-1][cycles-1]=step;//数组阶数是奇数时，最后一圈不是圈，只有一个点。这里直接对这个点赋值。
    
25.                         }
    
26.                         else{
    
27.                                 //第一条边
    
28.                                 for(int a=min;a<=max;a++){
    
29.                                         arr[min][a]=step++;
    
30.                                 }
    
31.                                 //第二条边
    
32.                                 for(int b=min+1;b<=max;b++){
    
33.                                         arr[b][max]=step++;
    
34.                                 }
    
35.                                 //第三条边
    
36.                                 for(int c=max-1;c>=min;c--){
    
37.                                         arr[max][c]=step++;
    
38.                                 }
    
39.                                 //第四条边
    
40.                                 for(int d=max-1;d>=min+1;d--){
    
41.                                         arr[d][min]=step++;
    
42.                                 }
    
43.                         }
    
44.                         count++;
    
45.                 }        
    
46.                 //输出数组
    
47.                 for(int m=0;m<num;m++){  
    
48.                         for(int n=0;n<num;n++){  
    
49.                                 System.out.print(arr[m][n]+"\t");  
    
50.                         }         
    
51.                         System.out.println("");  
    
52.                 }  
    
53.         }  
    
54. }

复制代码

加空格的程序用制表符就可以搞定了！

huanglyhf 发表于 2014-9-5 08:53
加空格的程序用制表符就可以搞定了！

嗯 谢谢 之前也想过每条边的做 感觉有点难 就放弃了 现在正好看看

1. public class Test9 {
   
2.         public static void main(String[] args) {
   
3.                 // 根据n创建一个二维数组
   
4.                 int n = 8;
   
5.                 int[][] arr = new int[n][n];
   
6.                 // 调用数组赋值的方法
   
7.                 method(arr);
   
8.                 // 将数组遍历出来
   
9.                 for (int i = 0; i < arr.length; i++) {
   
10.                         for (int j = 0; j < arr.length; j++) {
    
11.                                 System.out.print(arr[i][j] + "\t");
    
12.                         }
    
13.                         System.out.println("\n");
    
14.                 }
    
15. 
    
16.         }
    
17. 
    
18.         // 二维数组赋值方法
    
19.         public static void method(int[][] arr) {
    
20.                 // 创建数组的两个索引变量
    
21.                 int i = 0;
    
22.                 int j = 0;
    
23.                 // 通过 max 和min控制索引i，j的变化
    
24.                 int max = arr.length - 1;
    
25.                 int min = 0;
    
26.                 // 所需要赋的值
    
27.                 int num = 1;
    
28. 
    
29.                 while (min <= max) {
    
30.                         // 1、i不变j++ 向右
    
31.                         while (j < max) {
    
32.                                 arr[i][j++] = num++;
    
33.                         }
    
34.                         // 2、j不变i++ 向下
    
35.                         while (i < max) {
    
36.                                 arr[i++][j] = num++;
    
37.                         }
    
38.                         // 3、i不变j-- 向左
    
39.                         while (j > min) {
    
40.                                 arr[i][j--] = num++;
    
41.                         }
    
42.                         // 4、j不变i-- 向上
    
43.                         while (i > min) {
    
44.                                 arr[i--][j] = num++;
    
45.                         }
    
46.                         // 由于可能在n为奇数的时候无法为中心那个数赋值所以要补上这个数的赋值
    
47.                         if (min == max) {
    
48.                                 arr[i][j] = num;
    
49.                         }
    
50.                         max--;
    
51.                         min++;
    
52.                         // 循环一圈又开始想有赋值j++
    
53.                         j++;
    
54.                         // 由于向上的时候最后一次赋值i多减了一次所以每次外循环都要将i补回来
    
55.                         i++;
    
56.                 }
    
57.         }
    
58. }
    

复制代码

直接从1循环到N^2，i，j代表二维数组下标，初始值为0，二维数组也全部初始化为0。每次输出一个值：如果i=0或a[i-1][j]>0，则往右走；如果j=N-1或a[i][j+1]>0，则往下走;如果i=N-1或a[i+1][j]>0，则往左走；如果j=0或a[i][j-1]>0，则往上走。这样代码看起来会清楚很多

学习了。。。。。

左脑想你 发表于 2014-9-5 10:17

谢谢 分享 思路和代码都很简练 用while看起来很清爽啊 哈哈 :handshake

好难啊，还没学到数组怎么破

不错啊！

我也发个我写的~
package pack;

public class LuoXuan {

        /**
         * @param args
         */
        public static void main(String[] args) {
                func(5);
        }
       
        public static void func(int n)
        {
                int i=0,j=0,value=0;
                int arr[][]=new int[n][n];
                if(n%2==0)
                        arr[n/2][n/2-1]=n*n;
                else
                        arr[n/2][n/2]=n*n;
                for(j=0;j<n-1;j++)
                        arr[0][j]=++value;
                while(n>1)
                {
                        for(int x=0;x<n-1;x++)
                                arr[i++][j]=++value;
                        for(int x=0;x<n-1;x++)
                                arr[i][j--]=++value;
                        n--;
                        for(int x=0;x<n-1;x++)
                                arr[i--][j]=++value;
                        for(int x=0;x<n-1;x++)
                                arr[i][j++]=++value;
                        n--;
                }
               
               
                for(int ii=0;ii<arr.length;ii++)
                {
                        for(int jj=0;jj<arr[i].length;jj++)
                        {
                                System.out.print(arr[ii][jj]+"\t");
                        }
                        System.out.println();
                }
        }
}

方法好多

1. package com.itheima;
   
2. /**
   
3. *第9题：写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
   
4. * 如： n = 4 则打印：  
   
5. * 1         2         3         4
   
6. * 12 13 14 5
   
7. * 11 16 15 6
   
8. * 10         9         8         7      
   
9. * @author zl
   
10. *思路：给二维数组赋值的方法，一圈一圈地从外到内赋值，一圈即一个循环。
    
11. *详细：设为n维、h圈
    
12. *一，nxn维数组有h（(n+1)/2）圈，循环从外到内圈依次赋值；
    
13. *二，每圈由上、下行和左、右列共四个臂组成，按照上、右、下、左臂的先后顺序依次循环赋值；
    
14. *三，每个臂有元素n-h-(h-1)个，每臂以一个四角元素为起始元素依次赋值；
    
15. *四，四角元素索引分别为[h-1][h-1]、[h-1][n-h]、[n-h][n-h]、[n-h][h-1]。
    
16. *
    
17. *以n=4为例进行具体说明，此时h=2
    
18. *一共2圈；
    
19. *第1圈每臂有元素3个；第2圈每臂有元素2个；
    
20. *第1圈四角元素（每臂起始）分别为[0][0]、[0[3]、[3][3]、[3][0]；
    
21. *第1圈赋值顺序依次为：
    
22. *上臂元素为[0][0]、[0[1]、[0][2]；右臂元素为[0][3]、[1[3]、[2][3]；
    
23. *下臂元素为[3][3]、[3[2]、[3][1]；左臂元素为[3][0]、[2[0]、[1][0]；
    
24. *第2圈赋值顺序依次为
    
25. *上臂元素为[1][1]；右臂元素为[1][2]；
    
26. *下臂元素为[2][2]；左臂元素为[2][1]；
    
27. *
    
28. *注意一个特例：即最后一圈为一个元素时，需要做点例外处理。
    
29. */
    
30. public class Test09_2DArray {
    
31. 
    
32.         public static void main(String[] args) {
    
33.                 // 定义螺旋形二维数组并打印
    
34.                 int[][] arr = helixArray(6);
    
35.                 printArr(arr);
    
36.         }
    
37. 
    
38.         //定义静态方法，返回n行n列的螺旋形二维数组;
    
39.         static int[][] helixArray(int n) {
    
40.                 //定义二维数组、圈数和第一个元素的值
    
41.                 int[][] helArr = new int[n][n];
    
42.                 int helLen = (n+1)/2 ;
    
43.                 helArr[0][0] = 1;
    
44.                 //初始化; 从外圈到内圈依次赋值
    
45.                 for(int h=1; h<=helLen; h++) {
    
46.                         // 给第h圈的上臂[h-1]行的元素赋值；从第一列[h-1]到倒数最后一列[n-h-1]；第一圈与其他圈稍有不同，分开处理；
    
47.                         //考虑到最后一圈的元素可能只有一个，即每行或列的第一个元素与最后一个元素重合，因此有必要遍历到上行的最后一个元素[n-h]；
    
48.                         //如果不遍历到最后一个元素，则n为奇数即最后一圈为一个元素时，最后一个元素将得不到赋值。
    
49.                         for(int j=h-1; j<=n-h; j++) {
    
50.                                 if(h==1) {
    
51.                                         // 公式中helArr[h-1][h-1]是第1圈上臂行左边第一个元素，第一圈其余元素值根据第一个元素值依次获得
    
52.                                         helArr[h-1][j] = helArr[h-1][h-1] + j - (h - 1);
    
53.                                 } else {
    
54.                                         // helArr[h-1][h-2]是第h-1圈左臂列上面第一个元素，即非第一圈元素值根据第一圈最后一个元素值获得
    
55.                                         helArr[h-1][j] = helArr[h-1][h-2] + 1 + j - (h-1) ;
    
56.                                 }
    
57.                         }
    
58.                        
    
59.                         //给第h圈的右臂[n-h]列元素赋值；从第一行[h-1]到倒数最后一行[n-h-1]
    
60.                         for(int i=h-1; i<=n-h-1; i++) {
    
61.                                 // helArr[h-1][n-h-1]是第h圈上臂最后一个元素
    
62.                                 helArr[i][n-h] = helArr[h-1][n-h-1]+1 + i - (h - 1);
    
63.                         }
    
64. 
    
65.                         //给第h圈的下臂[n-h]行元素赋值；从右边第一列[n-h]向左到倒数第二列[h]
    
66.                         for(int j=n-h; j>=h; j--) {
    
67.                                 // helArr[n-h-1][n-h]是第h圈右右臂的最后一个元素
    
68.                                 helArr[n-h][j] = helArr[n-h-1][n-h]+ 1 + n-h- j;
    
69.                         }
    
70. 
    
71.                         //给第h圈的左侧列[h-1]元素赋值，从左侧列倒数第一行[n-h]向上到第二行[h]
    
72.                         for(int i=n-h; i>=h; i--) {
    
73.                                 // helArr[n-h][h]是第h圈下臂最后一个元素
    
74.                                 helArr[i][h-1] = helArr[n-h][h] + 1 + n - h - i;
    
75.                         }
    
76.                 }
    
77.                
    
78.                 return helArr;
    
79.         }
    
80.        
    
81.        
    
82.         //定义静态方法，打印二维数组; 添加制表符，对齐数组
    
83.         static void printArr(int[][] arr) {
    
84.                 for(int i=0; i<arr.length; i++) {
    
85.                         for(int j=0; j<arr[i].length; j++) {
    
86.                                 System.out.print(arr[i][j]+"\t");
    
87.                         }
    
88.                         //一行打印完，执行转行
    
89.                         System.out.println();
    
90.                 }
    
91.         }
    
92. }

复制代码

左脑想你 发表于 2014-9-5 10:17

和你思想 一样

左脑想你 发表于 2014-9-5 10:17

这个代码是最简单的，顶了。

我也写了一个，不过思路麻烦了一些。把二维数组看做地图上的点，然后把这个当做路径问题。
每一个地图点都有三个属性：坐标（x,y）、通行性(true/false)、位移矢量（dx,dy）。

规则是从（0,0）出发之后，一直直行（下一点坐标=本坐标+位移矢量），遇到无法通行的情况就向右拐（下一点坐标=本坐标+右转位移矢量）。

然后遍历到计数器=n*n为止。没有什么需要特殊处理的点。

这种方法缺点是代码量明显增加，看起来也不容易一眼看清。
优点是可以处理任意规则的转法，你喜欢S形也能给你走出来

左脑想你 发表于 2014-9-5 10:17

这个是我认为最好理解又最方便的方法   怒赞

左脑想你 发表于 2014-9-5 10:17

数组的方法厉害。

66666,好赞

还没想明白，仔细研究下