写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式

                地顺序排列。 如： n = 4 则打印：

                 1    2    3    4

                 12   13   14   5

                 11   16   15   6

                 10   9    8    7

1. package com.heima.text;
   
2. 
   
3. public class Demo4 {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 int[][] arr = new int[4][4];
   
7.                 int i = 0, j = 0;
   
8.                 int min = 0, max = arr.length - 1;
   
9.                 int num = 1;
   
10.                 while(min <= max) {
    
11.                         //向右
    
12.                         while(j < max) {
    
13.                                 arr[i][j++] = num++;
    
14.                         }
    
15.                         //向下
    
16.                         while(i < max) {
    
17.                                 arr[i++][j] = num++;
    
18.                         }
    
19.                         //向左
    
20.                         while(j > min) {
    
21.                                 arr[i][j--] = num++;
    
22.                         }
    
23.                         //向上
    
24.                         while(i > min) {
    
25.                                 arr[i--][j] = num++;
    
26.                         }
    
27.                         //当为奇数时 将最中间那个位置赋值
    
28.                         if(min == max) {
    
29.                                 arr[i][j] = num++;
    
30.                         }
    
31.                         min++;
    
32.                         max--;
    
33.                         i++;
    
34.                         j++;
    
35.                 }
    
36.                 //遍历数组
    
37.                 for(int x = 0; x < arr.length; x++) {
    
38.                         for(int y = 0; y < arr[x].length; y++) {
    
39.                                 System.out.print(arr[x][y] + "\t");
    
40.                         }
    
41.                         System.out.println();
    
42.                 }
    
43.         }
    
44. }
    

复制代码

好费脑子？你确定以后有用？

二楼正解.

这样的问题好像不学了啊

public class Test13 {

        /**
         * *9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。
         *  如： n = 4 则打印：
                 1    2    3    4
                 12   13   14   5
                 11   16   15   6
                 10   9    8    7
                 
                 分析:
                1.可以看出这个二维数组的每次变化的方向是:右-下-左-上-右...循环下去.
                只有4个方向循环.可以通过记录方向的变化次数 让变量模于4就可以确定 向哪个方向位移赋值元素
                2.每次变化方向位移的个数是:n,n-1,n-1,n-2,n-2....,1,1
                  计算出每次方向上位移的数,存储到数组中.以便于赋值的时候通过变化方向次数作为索引在数组中获取到该方向上的位移量
                 好通过for循环给每个方向上的元素成功赋值.
                3.每个元素的值是上一个元素的值+1
                4.确定好每次移动的方向和位移数就可以实现给二维数组赋值了.
                5.循环赋值停止的条件时二维数组的元素达到n*n个 就代表元素赋值完成.
                6.打印二维数组
               
                注意细节: 每次一个方向赋值完成后 要确定记录元素坐标的角标位置是否越界 是否回到正确的位置.
                        
         */
        public static void main(String[] args) {
                //创建键盘录入对象
                Scanner sc =new Scanner(System.in);
                System.out.println("请输入一个小于10 的正整数:");
                int n=sc.nextInt();
                //int n=4;
                int[][] arr= new int[n][n];
                //给二维数组的每个元素按指定的循环循序赋值
                setNumberToArray(arr,-1,-1,n,0);
                System.out.println("最终数组为:");
                printArray(arr);
        }
       
        private static void setNumberToArray(int[][] arr ,int i,int j,int n,int numbers) {
                //变量i,记录住元素的横坐标,变量j记录元素的纵坐标,变量n记录住二维数组的行列数,变量num
                //第三个元素表示二维数组的列数,第四个元素代表数组中总计有多少个数被赋值了.
                //定义一个数组来存储每次变化方向位移的个数是:n,n-1,n-1,n-2,n-2....1
                int[] sumCount=new int[2*n-1];
                //求出每一次转向前移动的位移
                for (int k = 0; k < sumCount.length; k++) {
                        if (k==0) {
                                sumCount[k]=n;
                        }else {
                                if (k%2==1) {
                                        sumCount[k]=(2*n-k-1)/2;
                                }else {
                                        sumCount[k]=(2*n-k)/2;
                                }
                        }
                        //System.out.println("sumCount "+sumCount[k]);
                }
               
           //下面的代码来实现循环给二维数组中的元素赋值为指定的值
       int m=0;     //记录住二维数组中元素的个数
       int count=0;//记录住第几次转向
       while(true){
               if (m==n*n) { //如果二维数组中的元素增加到n*n个就说明 赋值完成可以跳出循环赋值
                        break;
               }
              
               switch (count%4) {  //用次数模于4可以判断是向哪个方向增加位移
                        case 0:            //0方向代表向右位移赋值
                               
                                for (i++,j++; sumCount[count]--!=0; j++) {
                                        arr[j]= ++numbers;
                                        m++;
                                }
                                printArray(arr);
                                System.out.println("------------");
                                count++;
                                break;
                        case 1:            //1方向代表向下位移赋值
                               
                                for (i++,j--; sumCount[count]--!=0; i++) {
                                       
                                        arr[j]=++numbers;
                                        m++;
                                }
                                printArray(arr);
                                System.out.println("------------");
                                count++;
                                break;
                               
                        case 2:                                //2方向代表向左位移赋值
                               
                                for ( i--, j--; sumCount[count]--!=0; j--) {
                                        arr[j]=++numbers;
                                        m++;
                                }
                                printArray(arr);
                                System.out.println("------------");
                                count++;
                                break;
                               
                        case 3:                                //3方向代表向上位移赋值
                               
                                for (i--,j++; sumCount[count]--!=0; i--) {
                                        arr[j]=++numbers;
                                        m++;
                                }
                                printArray(arr);
                                System.out.println("------------");
                                count++;
                                break;
                               
                        default:
                                break;
                        }
       }
        }
       
        //打印二维数组
        public static void printArray(int[][] arr){
                for (int i = 0; i < arr.length; i++) {
                        for (int j = 0; j < arr.length; j++) {
                                System.out.print(arr[j]+"\t");
                        }
                        System.out.println();
                }
        }       
}