剑指Offer+第20题+顺时针打印矩阵+java

题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。例如：如果输入如下矩阵：

1，2，3，4

5，6，7，8

9，10，11，12

13，14，15，16

则依次打印出数字1，2，3，4，8，12，16，15，14，13，9，5，6，7，11，10.

 接下来分析循环结束的条件，假设这个矩阵的行数是rows，列数是columns，打印第一圈的左上角的坐标是（0，0），第二圈的左上角的坐标是（1，1），以此类推。我们注意到，左上角的坐标中行标和列标总是相同的。于是可以在矩阵中选取左上角为（start，start）的一圈为我们分析的目标。当n*n的矩阵而言，最一圈为（startX,startY),那么每行最多有(startY-1)*2个元素，每列最多有(startX-1)*2个元素，因此rows>startY*2并且columns>startX*2.
    接下来我们考虑如何打印一圈的功能，即如何实现PrintMatrixInCircle.我们可以把打印一圈分为四步：第一步从做到右打印一行，第二步从上到下打印一行，第三步从右到左打印一行，第四步从下到上打印一列。每一步我们根据起始坐标用一个循环就能打印出一行或者一列。不过值得注意的是，最后一圈有可能退化成只有一行、只有一列，甚至只有一个数字，因此打印这样的一圈就不再需要四步。

    因此我们要仔细分析打印时的每一步的前提条件。第一步总是需要的，因为打印一圈至少需要一步。如果只有一行，那么就不用第二步了。也就是需要第二步的前提条件是终止号大于起止号。需要第三步打印的前提条件是圈内至少有两行两列，也就是说除了要求终止行号大于起始行号之外，还要求终止列号大于起始列号。同理，需要打印第四步的前提条件是至少有三行两列，因此要求终止行号比其实行号至少大2，同时终止列号大于起始列号。
 

代码：

public class Offer20 {

	//循环打印矩阵
	public void printMatrixClockwisely(int [][] numbers){
		if(numbers == null)
			return;
		int rows = numbers.length;
		if(rows<=0)
			return;//这一句若是和下面的并在一起，就会在测试用例为arr={{}}时语句columns = numbers[0].length报错
		int columns = numbers[0].length;
		//if( columns <=0 )这句的判断条件删除没有影响
		//	return;
		
		int start = 0;
		while(columns >start*2 && rows > start*2){
			printMatrixCircle(numbers, start);
			start++;
		}
	}

	//打印一圈的功能
	public void printMatrixCircle(int[][] numbers, int start) {
		
		int endX = numbers[0].length -1 -start;
		int endY = numbers.length - 1 - start;
		
		//从左到右打印一行
		for(int i  = start; i<= endX;i++){
			int number = numbers[start][i];
			printNumber(number);
		}
		
		
		//从上到下打印一列
		if(start<endY){
			for(int i = start+1; i<=endY;i++){
				int number = numbers[i][endX];
				printNumber(number);
			}
		}
		
		//从右到左打印一行
		if(start<endY && start<endX){
			for(int i = endX-1;i>=start;i--){
				int number = numbers[endY][i];
				printNumber(number);
			}
		}
		
		//从下到上打印一列
		if(start<endX && start<endY-1){
			for(int i = endX-1;i>=start+1;i--){
				int number = numbers[i][start];
				printNumber(number);
			}
		}
	}

	public void printNumber(int number) {
		// TODO Auto-generated method stub
		System.out.print(number+"  ");
	}
	
	public static void main(String [] args){
		Offer20 of20 = new Offer20();
		
		//测试用例
		//数组有多行多列
		int array1[][] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}, {13,14,15,16}};
		of20.printMatrixClockwisely(array1);
		System.out.println();
		
		//数组只有一行
		int array2[][] = {{1,2,3,4}};
		of20.printMatrixClockwisely(array2);
		System.out.println();
		
		//数组只有一列
		int array3[][] = {{1},{2},{3},{4}};
		of20.printMatrixClockwisely(array3);
		System.out.println();
		
		//数组中只有一行一列
		int array4[][] = {{1}};
		of20.printMatrixClockwisely(array4);
		System.out.println();
		
		//数组中没有元素
		int array5[][] = {{}};
		of20.printMatrixClockwisely(array5);
		System.out.println();
		
		//数组中没有元素，语句columns = numbers[0].length;会报错所以最好在函数形参中给出columns和rows
		int array6[][] = {};
		of20.printMatrixClockwisely(array6);
		System.out.println();
		
		//数组为null
		int array7[][] = null;
		of20.printMatrixClockwisely(array7);
		System.out.println();
	}	
}

运行结果;

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

方法2（感觉更直观）

链接：https://www.nowcoder.com/questionTerminal/9b4c81a02cd34f76be2659fa0d54342a
来源：牛客网

import java.util.ArrayList;
public class Solution {
    ArrayList  a=new ArrayList();   new一个数组 以便下面函数能调用
    public ArrayList printMatrix(int [][] matrix) {
       int tR=0;
       int tC=0;
       int dR=matrix.length-1;
       int dC=matrix[0].length-1;
        while(tR<=dR&&tC<=dC){ 左上边界最多到达右下边界 用于判断是否还是剥圈打印
       printEdge(matrix,tR++,tC++,dR--,dC--);
        }
      return a;
    }
    public  void printEdge(int [][] m,int tR,int tC,int dR,int dC){
        if(tR==dR){    先判断是否只是一横行 如果是 打印该横行的列（通常用于内圈）
            for(int i=tC;i<=dC;i++){
                a.add(m[tR][i]);
            }
        }
        else if(tC==dC){  再判断是否只是一竖列 如果是 打印该横行的列（通常用于内圈
            for(int i=tR;i<=dR;i++){
                a.add(m[i][tC]);
            }
        }
        else {
            int curC=tC;用2个变量储存 用于判断当前位置
            int curR=tR;
            while(curC!=dC){      当前位置未到达当前行的最右列 --》往右去
                a.add(m[tR][curC]);
            curC++;
            }
            while(curR!=dR){      当前位置未到达当前列的最底行 --》往下去
                a.add(m[curR][dC]);
                curR++;
            }
            while(curC!=tC){      当前位置未到达当前行的最左列 --》往左去
                a.add(m[dR][curC]);
                curC--;
            }
            while(curR!=tR){      当前位置未到达当前列的最顶行 --》往上去
                a.add(m[curR][tC]);
                curR--;
            }
        }
    }
}