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

思路:
* 1. 按螺旋的圈数进行循环，对于n阶方阵，螺旋圈数是(n+1)/2.
* 2. 每一圈都是按顺时针走，顺时针位置上的值依次增加，可以先循环列出向右增长的横行和向下增长的竖列的值，剩下的半圈的值可利用对称性得到。
* 3. 里面一圈的起始值是它外面一圈左侧位置上的值加1

浪费了好多脑细胞。。。。

1. public static void main(String[] args) {  
   
2.         LXArray(4);  
   
3.     }  
   
4.     public static void LXArray(int n){  
   
5.         int[][] arr=new int[n][n];  
   
6.         //如果每一圈开头位置相邻左侧位置的值为start,那每一圈开头的值就是start+1，最外面一圈的start值设置为0  
   
7.         int start=0;  
   
8.         //按螺旋的圈数进行循环，给定n值的方阵，其螺旋的圈数(n+1)/2  
   
9.         for(int t=0;t<(n+1)/2;t++){  
   
10.             //除第一圈外，从外向里，每一圈的开头起始值是其左侧紧邻位置的值+1，即start+1  
    
11.             if(t!=0){  
    
12.                 start=arr[t][t-1];  
    
13.             }  
    
14.             //获取每一圈往右增长的一行和往下增长的一列的值，每一圈的元素个数是随着圈从外向内的层次数而变化的，用j表示，i代表每一圈向右的一行相对起始值的偏移  
    
15.             for(int j=t,i=0;j<n-t&&i<=j;j++,i++){           
    
16.                 arr[t][j]=start+i+1;  
    
17.                 //圈子越向内时，每行或每列的元素个数会减少，所以转折的越快  
    
18.                 arr[j][n-1-t]=start+i+n-2*t;  
    
19.             }  
    
20.             //获得每一圈往右增长的一行和往下增长的一列的值，向左增长的行数据和向上增长的列数据分别利用对称特性行到，每对对称位置的两个元素加起来的值都是该层最右下角元素值的2倍。  
    
21.             for(int i=t+1;i<n-t;i++){  
    
22.                 arr[i][t]=2*arr[n-1-t][n-1-t]-arr[t][i];  
    
23.                 arr[n-1-t][i]=2*arr[n-1-t][n-1-t]-arr[i][n-1-t];  
    
24.             }  
    
25.         }  
    
26.         printLXarray(arr);  
    
27.     }  
    
28.     //打印数组的函数  
    
29.     public static void printLXarray(int[][] arr){  
    
30.         for(int i=0;i<arr.length;i++){  
    
31.             for(int j=0;j<arr[i].length;j++){               
    
32.                 System.out.printf("%4d",arr[i][j]);  
    
33.             }  
    
34.             System.out.println();  
    
35.         }  
    
36.     }  

复制代码

看的有点乱，我还没学好……还需努力

1. public class ArrayPrint {
   
2.         /**
   
3.          * @param args
   
4.          */
   
5.         public static void main(String[] args) {  
   
6.        int[][] arr = arrayInit(4);
   
7.         printLXarray(arr);
   
8.     }  
   
9.         public static int[][] arrayInit(int n){
   
10.                 int[][] arr = new int[n][n];
    
11.                 int start = 0;
    
12.                 int end = n-1;
    
13.                 int key =1;
    
14.                 while((end-start)>=0){
    
15. //                        只要结束标记和开始标记不相同，那么循环进入下一圈
    
16.                         for(int i = start,j= start;j<=end;j++,key++){
    
17.                                 arr[i][j] = key;
    
18.                         }
    
19.                         for(int i = start+1,j= end;i<=end;i++,key++){
    
20.                                 arr[i][j] = key;
    
21.                         }
    
22.                         for(int i = end,j= end-1;j>=start;j--,key++){
    
23.                                 arr[i][j] = key;
    
24.                         }
    
25.                         for(int i = end-1,j= start;i>=start+1;i--,key++){
    
26.                                 arr[i][j] = key;
    
27.                         }
    
28. //                        用四个for循环走完一圈
    
29.                         start++;
    
30.                         end--;
    
31. //                        走完后再修改开始和结束的标记，进入下一圈
    
32.                 }
    
33.                 return arr;
    
34.         }
    
35.    
    
36.     public static void printLXarray(int[][] arr){  
    
37.     //打印数组的函数
    
38.             for(int i=0;i<arr.length;i++){  
    
39.             for(int j=0;j<arr[i].length;j++){               
    
40.                 System.out.printf("%4d",arr[i][j]);  
    
41.             }  
    
42.             System.out.println();  
    
43.         }  
    
44.     }  
    
45. }

复制代码

大家觉得这样写会不会更简洁一点

冥夜 发表于 2014-12-18 16:28
import java.util.Arrays;

/*

可以刷下OJ了。。。。

先占一个

import java.util.Arrays;

/*
1.既然是螺旋走就螺旋赋值。用num保存数字，x为横坐标，y为纵坐标。
  123
  894
  765
  */
public class Luoxuan
{
        public static void main(String[] args)
        {
                printLuoxuan(6);
        }

        private static void printLuoxuan(int i)
        {
                //整体思路，既然是螺旋矩阵就螺旋赋值，num为保存的数字。首先观察到赋值是向右，向下，向左，向上进行赋值，然后每次都重复这个过程直到全部赋值完毕。
                //每完成一次循环都会使坐标值变化1.所以用count表示圈数来进行赋值
                int[][] arr=new int[i][i];
                int num=1;//赋值的数字
            int count=0;//圈数
                while(num<(i*i+1))//i阶螺旋矩阵总共i*i个数
                {
                        for(int j=count;j<i-count;j++)//从最左上开始赋值，向右赋值。第一圈纵坐标是0，第二是1.。。
                                arr[j][count]=num++;
                       
                        for(int j=count+1;j<i-count;j++)//向下赋值，第一圈横坐标是i-1，第二圈是i-2..。
                                arr[i-count-1][j]=num++;
                               
                        for(int j=i-count-2;j>count-1;j--)//向左赋值，第一圈纵坐标是i-1，第二圈是i-2。。。
                                arr[j][i-count-1]=num++;
                       
                        for(int j=i-count-2;j>count;j--)//向上赋值，第一圈横坐标是0，第二圈是1.。。
                                arr[count][j]=num++;
                        count++;//走完一圈圈数+1
                }
               
                for(int y=0;y<i;y++)
                {
                        for(int x=0;x<i;x++)
                        {
                                System.out.print(arr[x][y]+"\t");
                        }
                        System.out.println();
                }
        }
}
我以前写的- -

都好膩害

十万一千 发表于 2014-12-18 13:28
我的入学测试也有这题，交流一下吧！

感觉也不错的。。。

我的入学测试也有这题，交流一下吧！

1. public class Test9 {
   
2.         public static void main(String[] args) {
   
3.                 int length = 25;
   
4.                 int[][] array = new int[length][length];
   
5. 
   
6.                 dos(array, 1, 0);
   
7. 
   
8.                 for (int i = 0; i < length; i++) {
   
9.                         for (int j = 0; j < length; j++) {
   
10.                                 System.out.print(array[i][j] + "\t");
    
11.                         }
    
12.                         System.out.println();
    
13.                 }
    
14.         }
    
15. 
    
16.         private static void dos(int[][] array, int count, int padding) {
    
17.                 if (padding == (array.length / 2)) {
    
18.                         if (array.length % 2 == 1) {
    
19.                                 array[array.length / 2][array.length / 2] = count;
    
20.                         }
    
21.                         return;
    
22.                 }
    
23.                 int L = array.length - padding - 1;
    
24.                 for (int i = 0; i <= L - padding; i++) {
    
25.                         array[padding][padding + i] = count++;
    
26.                 }
    
27.                 for (int i = 1; i <= L - padding; i++) {
    
28.                         array[padding + i][L] = count++;
    
29.                 }
    
30.                 for (int i = 1; i <= L - padding; i++) {
    
31.                         array[L][L - i] = count++;
    
32.                 }
    
33.                 for (int i = 1; i <= L - padding - 1; i++) {
    
34.                         array[L - i][padding] = count++;
    
35.                 }
    
36.                 padding++;
    
37.                 dos(array, count, padding);
    
38.         }
    
39. }

复制代码

先占一个。。。。