剑指offer：顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 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.

思路：

用minRow,minCol,maxRow,maxCol来控制圈数，每打印完一行，或者一列，相应的最大最小行列数进行加减1。

具体的，分为

step（1）从左往右打印，打印完以后，最小行+1；此时到了最后一列

step（2）从上往下打印，打印完以后，最大列-1；此时到了最后一行

step（3）从右往左打印，打印完以后，最大行-1；此时到了第一列

step（4）从下往上打印，打印完以后，最大行-1；此时到了第二行

这是一圈，剩余的圈数和上面步骤一样。

还有一些具体需要注意的关键点，会在代码中以注释的形式写出来。

实现1：

package com.day01;

import java.util.ArrayList;

class printMatrixDemo {
	/*解题思路：最直观的方法，
	 * 1.从外圈到里圈，一圈一圈打印，
	 * 2. 向内再走一圈，接着循环。
	 * 3. 要返回的数组下标达到n*m时，说明所有的值遍历完了，结束循环。
	 * 
	 * 访问完最小行的每一个元素，最小行+1
	 * 访问完最大行的每一个元素，最大行-1
	 * 访问完最大列中的每个元素，最大列-1
	 * 访问完最小列中的每个元素，最小列+1*/
	 public ArrayList<Integer> printMatrix(int [][] matrix) {
		 if(matrix==null){
			 return null;
		 }
		 int minRow=0;
		 int minCol=0;//最小行，最小列
		 int maxRow=matrix.length-1;
		 int maxCol=matrix[0].length-1;//最大行和最大列
		 int i=0,j=0;//i表示行，j表示列
		 int count=matrix.length*matrix[0].length;
		 ArrayList<Integer> arraylist=new ArrayList<>();
		 //结束的条件：存在链表中的元素个数和二维数组中的元素总个数相等了
		 while(arraylist.size()<count){
			 //从左往右
			 while(j<=maxCol&&arraylist.size()<count){
				 arraylist.add(matrix[i][j++]);
			 }
			 //打印完一行,最小行+1
			 minRow++;
			 //打印完一行的最后一个元素，j就加到了最大索引+1的位置，越界了，所以对j进行-1操作
			 j--;
			 //因为从上往下打印的第一个元素，从左往右打印的时候已经打印过了，所以i+1进入下一行
			 i++;
			 //从上往下打印
			 while(i<=maxRow&&arraylist.size()<count){
				 arraylist.add(matrix[i++][j]);
			 }
			 //打印完一列，最大列-1
			 maxCol--;
			 //打印完一列的最后一个元素后，i++后i越界，所以对i进行-1操作
			 i--;
			 //从右往左打印的第一个元素从上往下已经打印过了，所以j进行-1操作
			 j--;
			 //从右往左打印
			 while(j>=minCol&&arraylist.size()<count){
				 arraylist.add(matrix[i][j--]); 
			 }
			 //打印完一行，最大行-1
			 maxRow--;
			 //j变为-1，越界，j进行+1
			 j++;
			 //从下往上打印的第一个元素从右往左已经打印过了，i-1
			 i--;
			 //从下往上打印
			 while(i>=minRow&&arraylist.size()<count){
				 arraylist.add(matrix[i--][j]);
			 }
			 //打印完一列，最小列+1
			 minCol++;
			 i++;
			 j++;
			 
			 //加上最后一个元素
			 if(arraylist.size()==count-1){
				 arraylist.add(matrix[i][j]);
			 }
		 }
		 
		return arraylist;
	       
	    }
    //测试代码
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 int numbers[][]= {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}};
		 int numbers2[][]= {{1,2,3},{4,5,6},{7,8,9},};
		 printMatrixDemo pmd=new printMatrixDemo();
		 ArrayList<Integer> list=pmd.printMatrix(numbers2);
		 System.out.println(list.toString());

	}

}

参考了这篇博客的实现方法，https://www.cnblogs.com/yi-hui/p/8892683.html。但是原博客中有一些问题，会造成数组索引越界，我在代码中已经备注出来了。

 

另外，参考了这篇博客的另外一种实现：https://blog.csdn.net/u013132035/article/details/80594659

关于思路，博主画图也讲得很清楚了，

      * 假设矩阵的行数为rows,列数为columns.打印第一圈的左上角坐标为（0,0），第二圈左上角坐标为（1，1），以此类推。
      * 可以看到左上角的行标和列表总是相同的。于是可以在矩阵中选取左上角（start，start）的一圈作为我们的分析目标。
      * 对于5*5的矩阵，最后一圈只有一个数字，对应的坐标为（2,2）。5——2*2
      * 对于6*6的矩阵，最后一圈有4个数字，左上角的坐标仍然是（2,2）。6——2*2
      * 故循环继续的条件为：columns>startX*2,且rows>startY*2
      * 打印一圈需要四步，从左到右，从上到下，从右到左，从下到上。
      * 分析一下每一步的前提条件：
      * （1）第一步总是要有的，因为打印一圈至少有一步。如果只有一行，那就不需要第二步了。
      * （2）第二步的前提条件是，终止行号大于起始行号。
      * （3）第三步的前提条件是，圈内至少有2行2列；即除了要求终止行号大于起始行号外，还要求终止列号大于起始列号。
      * （4）第四步的前提条件是：圈内至少有3行2列，终止行号要比起始行号大2，同时终止列号大于起始列号。
      * 注意：最后一圈可能退化为只有一行，只有一列，甚至只有一个数字。因此打印这样的一圈不需要4步，可能只需要3,2,1步

实现2：

	 public ArrayList<Integer> printMatrix1(int [][] matrix) {
		 ArrayList<Integer> list=new ArrayList<>();
		 int rows=matrix.length;
		 int cols=matrix[0].length;
		 if(matrix==null||cols<=0||rows<=0){
			 return null;
		 }
		 int start=0;
		 while(cols>start*2&&rows>start*2){
			 printMatrixInCircle(list,matrix,cols,rows,start);
			 ++start;
		 }
		return list;
		 
	 }

	private void printMatrixInCircle(ArrayList<Integer> list, int[][] matrix, int cols, int rows, int start) {
		// TODO Auto-generated method stub
		int endX=cols-1-start;
		int endY=rows-1-start;
		//从左往右
		for(int i=start;i<=endX;++i){
			list.add(matrix[start][i]);		
		}
		//从上往下打印一列
		if(endY>start){
			for(int i=start+1;i<=endY;++i){
				list.add(matrix[i][endX]);
			}
		}
		//从左往右打印一行
		if(endY>start&&endX>start){
			for(int i=endX-1;i>=start;--i){
				list.add(matrix[endY][i]);
			}
		}
		//从下往上打印一列
		if(endY-start>1&&endX>start){
			for(int i=endY-1;i>=start+1;--i){
				list.add(matrix[i][start]);
			}
		}
		
	}