顺时针打印n*n二维数组。（第一次博客不喜勿喷）

给定一个二维数组

int [][] nums = {

{1,2,3,4},

{4,5,6,7},

{7,8,9,10},

{11,12,13,14}

}

顺时针打印结果应为：

1，2，3，4，7，10，14，13，12，11，7，4，5，6，9，8

创建类 声明一个init方法

package CSDN;

public class T1顺时针打印二维数组 {
       
}

public class T1顺时针打印二维数组 {
       private static void init() {
		// TODO Auto-generated method stub
      
	}
}

我们在init方法中生成数组并将数组初始化。

  private static void init() {
		// TODO Auto-generated method stub
          System.out.println("请输入阶数");
          Scanner scanner = new Scanner(System.in);
          int  n = scanner.nextInt();
          //初始化二维数组。
         int[][] nums = new int[n][n];
	}

在init方法中使用两个for嵌套进行给二维数组进行赋值，

       private static void init() {
		// TODO Auto-generated method stub
          System.out.println("请输入阶数");
          Scanner scanner = new Scanner(System.in);
          int  n = scanner.nextInt();
          //初始化二维数组。
         int[][] nums = new int[n][n];
         
         int count  =0;//定义一个count运用赋值
         for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[0].length; j++) {
				 nums[i][j] = ++count;
				 System.out.print(nums[i][j]+"\t");  //将生成的数组大于出来
			}
			System.out.println();
		}
	}

将我们现在在main方法中调用运行一下

输入5打印的结果为：

请输入阶数
5
1       2      3     4      5    
6       7      8     9     10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    

我们现在声明一个带参数的print(int [][] nums,int n)方法用于传递二维数组和阶数

并且顺时针打印二维数组。

  private static void print(int [] []nums,int n) {
		// TODO Auto-generated method stub

	}

将需要的变量定义好：

private static void print(int [] []nums,int n) {
		// TODO Auto-generated method stub
    	   //确定二维数组边界  (x1,y1)(x2,y2)
           int x1=0,y1=0,x2 = n-1,y2  = n-1;
           //确定二维数组打印的开始位置
           int x=x1,y=y1;
           
	}

接下来我们要打印的是二维数组的第一行

1       2      3     4      5    
6       7      8     9     10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    

 //打印二维数组第一行 也就是二维数组的上面
 //因此第一行x不动  y也就是列动因此 y不能大于y2

 private static void print(int [] []nums,int n) {
		// TODO Auto-generated method stub
    	   //确定二维数组边界  (x1,y1)(x2,y2)
           int x1=0,y1=0,x2 = n-1,y2  = n-1;
           //确定二维数组打印的开始位置
           int x=x1,y=y1;
           
           //打印二维数组第一行 也就是二维数组的上面
           //因此第一行x不动  y也就是列动因此 y不能大于y2
           while(y<=y2) {
        	     System.out.print(nums[x][y++]);
           }
           //当y运动到 y=y2是 进行最后一次打印后  y=5  超出了数组下标
           //我们要进行恢复
           y = y2;
           //且我们要进行下一行的打印
           ++x;
           
	}

我们在init方法中打印

package CSDN;

import java.util.Scanner;

public class T1顺时针打印二维数组 {
	  public static void main(String[] args) {
		init();
		
	}
       private static void init() {
		// TODO Auto-generated method stub
          System.out.println("请输入阶数");
          Scanner scanner = new Scanner(System.in);
          int  n = scanner.nextInt();
          //初始化二维数组。
         int[][] nums = new int[n][n];
         
         int count  =0;//定义一个count运用赋值
         for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[0].length; j++) {
				 nums[i][j] = ++count;
				 System.out.print(nums[i][j]+"\t");  //将生成的数组大于出来
			}
			System.out.println();
		}
         print(nums,n);
	}
       private static void print(int [] []nums,int n) {
    	   System.out.println("结果");
		// TODO Auto-generated method stub
    	   //确定二维数组边界  (x1,y1)(x2,y2)
           int x1=0,y1=0,x2 = n-1,y2  = n-1;
           //确定二维数组打印的开始位置
           int x=x1,y=y1;
           
           //打印二维数组第一行 也就是二维数组的上面
           //因此第一行x不动  y也就是列动因此 y不能大于y2
           while(y<=y2) {
        	     System.out.print(nums[x][y++]+"\");
           }
           //当y运动到 y=y2是 进行最后一次打印后  y=5  超出了数组下标
           //我们要进行恢复
           y = y2;
           //且我们要进行下一行的打印
           ++x;
           
	}
}

打印结果为：

请输入阶数
5
1    2    3    4    5    
6    7    8    9    10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    
结果
1    2    3    4    5

            /*
            * 我们打印了第一行之后要进行 右边一列的一些
            * y不动 x也就是行动 且x<=x2
            */

 /*
            * 我们打印了第一行之后要进行 右边一列的一些
            * y不动 x也就是行动 且x<=x2
            */
           while(x<=x2) {
        	   System.out.print(nums[x++][y]+"\t");
           }
           /*
                      * 当x运动到 x=x2时进行最后一次打印后  x=5  超出了数组下标
            */
           x = x2;
           --y;

打印结果为：

请输入阶数
5
1    2    3    4    5    
6    7    8    9    10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    
结果
1    2    3    4    5    10    15    20    25    

 我们打印了右边一列行之后要进行最后一行的打印
 x不动 y也就是行动 且y>=y1
           

  
           while(y>=y1) {
        	   System.out.print(nums[x][y--]+"\t");
           }
           y = y1;
           x--;

打印的结果为：

请输入阶数
5
1    2    3    4    5    
6    7    8    9    10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    
结果
1    2    3    4    5    10    15    20    25    24    23    22    21

 我们打印了最后一行之后要进行第一列的打印

 y不动 x也就是列行动 且x>x1;

   while(x>x1) {
        	   System.out.print(nums[x--][y]+"/t");
           }

打印的结果为：

请输入阶数
5
1    2    3    4    5    
6    7    8    9    10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25    
结果
1    2    3    4    5    10    15    20    25    24    23    22    21    16    11    6    

这个时候已经打印了一圈 我们的边界要缩小一圈

1       2      3     4      5    
6       7      8     9     10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25  

 边界x1++; y1++; x2--; y2--;

  在二维数组中如果 (x1,y1)  和 (x2,y2)

   x1<=x2  且 y1<=y2 的时候二维数组才有需要继续打印

当 x1=x2 且 y1=y2 时这个时候 边界已经相交了如果打印会导致交叉打印

使用 当 x1<=x2  且 y1<=y2时我们的二维数组才需要继续打印

package CSDN;

import java.util.Scanner;

public class T1顺时针打印二维数组 {
	  public static void main(String[] args) {
		init();
		
	}
       private static void init() {
		// TODO Auto-generated method stub
          System.out.println("请输入阶数");
          Scanner scanner = new Scanner(System.in);
          int  n = scanner.nextInt();
          //初始化二维数组。
         int[][] nums = new int[n][n];
         
         int count  =0;//定义一个count运用赋值
         for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[0].length; j++) {
				 nums[i][j] = ++count;
				 System.out.print(nums[i][j]+"\t");  //将生成的数组大于出来
			}
			System.out.println();
		}
         print(nums,n);
	}
       private static void print(int [] []nums,int n) {
    	   System.out.println("结果");
		// TODO Auto-generated method stub
    	   //确定二维数组边界  (x1,y1)(x2,y2)
           int x1=0,y1=0,x2 = n-1,y2  = n-1;
           //确定二维数组打印的开始位置
           
           
       while(x1<=x2&&y1<=y2) {
    	   
      
           int x=x1,y=y1;
           
           //打印二维数组第一行 也就是二维数组的上面
           //因此第一行x不动  y也就是列动因此 y不能大于y2
           while(y<=y2) {
        	     System.out.print(nums[x][y++]+"\t");
           }
           //当y运动到 y=y2是 进行最后一次打印后  y=5  超出了数组下标
           //我们要进行恢复
           y = y2;
           //且我们要进行下一行的打印
           ++x;
           
           
           /*
                      * 我们打印了第一行之后要进行 右边一列的一些
            * y不动 x也就是行动 且x<=x2
            */
           while(x<=x2) {
        	   System.out.print(nums[x++][y]+"\t");
           }
           /*
                      * 当x运动到 x=x2时进行最后一次打印后  x=5  超出了数组下标
            */
           x = x2;
           --y;
           
           while(y>=y1) {
        	   System.out.print(nums[x][y--]+"\t");
           }
           y = y1;
           x--;
           
           while(x>x1) {
        	   System.out.print(nums[x--][y]+"\t");
           }
           
           x1++; y1++; x2--; y2--;
       }
	}
}

 打印的结果为：

请输入阶数
5
1       2      3     4      5    
6       7      8     9     10    
11    12    13    14    15    
16    17    18    19    20    
21    22    23    24    25   
结果
1    2    3    4    5    10    15    20    25    24    23    22    21    16    11    6    7    8    9    14    19    18    17    12    13    

也就将二维数组打印出来了。

今天小编就到这了，要睡觉了，不熬夜头发要紧。

 大家有时间可以思考一些 逆时针打印二维数组。

（谢谢的收看，第一次写博客不喜勿喷）