首页 > 试题广场 > 顺时针打印矩阵
[编程题]顺时针打印矩阵
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下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.

232个回答

添加回答
推荐
/*解题思路:顺时针打印就是按圈数循环打印,一圈包含两行或者两列,在打印的时候会出现某一圈中只包含一行,要判断从左向右打印和从右向左打印的时候是否会出现重复打印,同样只包含一列时,要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int>res;
        res.clear();
        int row=matrix.size();//行数
        int collor=matrix[0].size();//列数
        //计算打印的圈数
        int circle=((row<collor?row:collor)-1)/2+1;//圈数
        for(int i=0;i<circle;i++){
            //从左向右打印
            for(int j=i;j<collor-i;j++)
                res.push_back(matrix[i][j]);          
            //从上往下的每一列数据 
            for(int k=i+1;k<row-i;k++)
                res.push_back(matrix[k][collor-1-i]);
            //判断是否会重复打印(从右向左的每行数据) 
            for(int m=collor-i-2;(m>=i)&&(row-i-1!=i);m--) 
                res.push_back(matrix[row-i-1][m]); 
            //判断是否会重复打印(从下往上的每一列数据)
            for(int n=row-i-2;(n>i)&&(collor-i-1!=i);n--) 
                res.push_back(matrix[n][i]);}
        return res;
    }
};


编辑于 2015-09-07 13:31:21 回复(43)
//用while感觉比for好看多了
import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> result = new ArrayList<>();
    public ArrayList<Integer> printMatrix(int [][] matrix) {
       int rowS = 0; 
       int colS = 0; 
       int rowE = matrix.length-1;
       int colE = matrix[0].length-1;
       
       while(rowS<=rowE && colS<=colE) {
           orderMatrix(rowS++,rowE--,colS++,colE--,matrix);
       }
        return result;
    }

    private void orderMatrix(int rowS, int rowE, int colS, int colE, int[][] matrix) {
        //剩下一行时,打印单行
        if(rowS==rowE) { 
            for(int i = colS;i<=colE;i++) {
                result.add(matrix[rowS][i]);
            }
        }
        //剩下一列时,打印单列
        else if(colS==colE) { 
            for(int i = rowS;i<=rowE;i++) {
                result.add(matrix[i][colS]);
            }
        }
        else {
            int rowC = rowS; //currentRow 表示当前行
            int colC = colS; //currentCol 表示当前列
            
            // 左上→右上
            while(colC!=colE) { 
                result.add(matrix[rowC][colC++]);
            }
            //右上→右下
            while(rowC!=rowE) {
                result.add(matrix[rowC++][colC]);
            }
            //右下→左下
            while(colC!=colS) {
                result.add(matrix[rowC][colC--]);
            }
            //左下→左上
            while(rowC!=rowS) {
                result.add(matrix[rowC--][colC]);
            }
        }
        
    }
}
发表于 2019-06-17 10:46:03 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
       ArrayList<Integer> result = new ArrayList<Integer>();
       if(matrix.length == 0)
           return result;
        int row = matrix.length;//矩阵行数
        int column = matrix[0].length;//矩阵列数
        if(column==0)
            return result;
        int cycles = ((row<column?row:column)-1)/2+1;//总共的圈数
        for(int i=0;i<cycles;i++){//共执行这么多圈
            for(int k = i;k<column-i;k++)//左到右
                result.add(matrix[i][k]);
            for(int j=i+1;j<row-i;j++)//右上到右下
                result.add(matrix[j][column-i-1]);
            for(int k =column-i-2;(k>=i)&&(row-i-1>i);k--)//右到左
                result.add(matrix[row-i-1][k]);
            for(int j = row-i-2;(j>i)&&(column-i-1>i);j--)//左下到左上
                result.add(matrix[j][i]);
        }
        return result;
    }
}
发表于 2019-06-04 21:02:52 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList printMatrix(int [][] matrix) {
        ArrayList list=new ArrayList();
        int x=0,y=0,dx=0,dy=1,len1=matrix.length,len2=matrix[0].length;
        int total=len1*len2;
        for(int i=0;i<total;i++){
            list.add(matrix[x][y]);
            matrix[x][y]=Integer.MIN_VALUE;
            if(matrix[(x+dx+len1)%len1][(y+dy+len2)%len2]==Integer.MIN_VALUE){
                int t=dx;
                dx=dy;
                dy=-t;
            }
            x+=dx;
            y+=dy;
        }
        return list;
    }
}
发表于 2019-06-03 16:37:52 回复(0)
/*下面是我按照剑指offer书上的思路编写的,按圈输出,每圈最多需要四步。*/
import java.util.ArrayList; public class Solution {     public ArrayList<Integer> printMatrix(int [][] matrix) {        int row=matrix.length;         int col=matrix[0].length;         int sta=0;         ArrayList<Integer> result = new ArrayList<Integer>() ;         if(matrix==null || matrix.length==0) { return result; }         while (row>sta*2&&col>sta*2){             PrintInCircle(matrix,row,col,sta,result);             sta++;         }         return result ;     }     public void PrintInCircle(int [][] matrix,int row,int col,int sta,ArrayList<Integer> result){         int Endrow=row-sta-1;         int Endcol=col-sta-1;         for(int i=sta;i<=Endcol;i++)             result.add(matrix[sta][i]);         if(sta<Endrow){         for(int i=sta+1;i<=Endrow;i++)             result.add(matrix[i][Endcol]);         }         if(sta<Endcol&&sta<Endrow){         for(int i=Endcol-1;i>=sta;i--)             result.add(matrix[Endrow][i]);     }         if(sta<Endcol&&sta<Endrow-1){         for(int i=Endrow-1;i>=sta+1;i--)             result.add(matrix[i][sta]); }     } }

编辑于 2019-05-30 18:20:55 回复(0)
第一感觉就是用递归,每次把最外层打印了,里面的依然是同一个问题,因此递归下去,边界条件就是:左边界大于右边界 上边界大于下边界

importjava.util.ArrayList;
publicclassSolution {
    publicArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> arrays = newArrayList<>();
        if(matrix == null)
            returnarrays;
        recurPrint(matrix,0,matrix[0].length-1,0,matrix.length-1,arrays);
        returnarrays;
    }
 
 
 
    publicvoidrecurPrint(int[][] matrix,intleft,intright,inttop,intabove,ArrayList<Integer> arrays){
        if(left > right || top > above){
            return;
        }
        if(left == right){
            for(inti = top ;i<=above ;i++){
                arrays.add(matrix[i][right]);
            }
        }elseif(above == top){
            for(inti = left ;i<=right ;i++){
                arrays.add(matrix[left][i]);
            }
        }else{
            for(inti=left ;i<=right;i++){
                arrays.add(matrix[top][i]);
            }
 
            for(inti=top+1;i<=above;i++){
                arrays.add(matrix[i][right]);
            }
 
            for(inti=right-1;i>=left;i--){
                arrays.add(matrix[above][i]);
            }
            for(inti= above-1;i>top;i--){
                arrays.add(matrix[i][left]);
            }
        }
        recurPrint(matrix,left+1,right-1,top+1,above-1,arrays);
    }
}

发表于 2019-05-28 10:46:24 回复(0)
按方向一层层忘里遍历,遍历个数等于总数目时跳出
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        int i = 0, j = 0;
        int h = matrix.length;
        int w = matrix[0].length;
        int number = 0;
        int k=0; // 层数
        list.add(matrix[i][j]);
        number++;
        while(number < h * w) {
            while((j+1) < w-k && number < h * w) {
                j++;
                list.add(matrix[i][j]);
                number++;
            }
            while((i+1) < h-k && number < h * w) {
                i++;
                list.add(matrix[i][j]);
                number++;
            }
            while((j-1)>=k && number < h * w){
                j--;
                list.add(matrix[i][j]);
                number++;
            }
            while((i-1)>=k+1 && number < h * w) {
                i--;
                list.add(matrix[i][j]);
                number++;
            }
            k++;
        }
        return list;
    }
}
发表于 2019-05-28 00:50:12 回复(0)

```
public ArrayList result=new ArrayList();

public ArrayList<Integer> printMatrix(int [][] matrix) {
    printalayer(matrix);
    return this.result;


}
public void printalayer(int [][] matrix){




    if (matrix.length ==1&&matrix[0].length==1){

            result.add(matrix[0][0]);
        }
    if (matrix.length ==1&&matrix[0].length!=1){

        for (int i = 0; i < matrix[0].length; i++) {
            result.add(matrix[0][i]);
        }
    }
    if (matrix.length !=1&&matrix[0].length==1){

        for (int i = 0; i < matrix.length; i++) {
            result.add(matrix[i][0]);
        }
    }

    else if (matrix.length !=1&&matrix[0].length!=1){
        for (int i = 0; i <matrix[0].length ; i++) {
            result.add(matrix[0][i]);

        }
        for (int i = 1; i <matrix.length ; i++) {
            result.add(matrix[i][matrix[0].length-1]);
            int j=matrix[0].length-1;
        }

        int[][] ma=new int[matrix.length-1][matrix[0].length-1];

        for (int i = matrix.length-1; i >0 ; i--) {
            for (int j = matrix[0].length-2; j >=0 ; j--) {
                ma[matrix.length-1-i][matrix[0].length-2-j]=matrix[i][j];
            }
        }
        printalayer(ma);

    }
}

```输出最上一列最右一列,然后存进数组,转换剩余部分方向,然后递归。

发表于 2019-05-25 18:10:38 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {

        ArrayList<Integer> list = new ArrayList<Integer>();
        int rLength = matrix.length;         //行数
        int cLength = matrix[0].length;   //列数
        //计算打印的圈数
        int circle = ((rLength<cLength?rLength:cLength)-1)/2+1;   //行和列谁少选谁

        for (int i = 0; i < circle; i++) {

            //从左向右打印
            for (int j = i; j < cLength-i; j++) {
                list.add(matrix[i][j]);
            }

            //从上到下打印
            for (int j = i+1; j < rLength-i; j++) {
                list.add(matrix[j][cLength-i-1]);
            }

            //从右向左打印
            for (int j = cLength-2-i; j >=i && (rLength-i-1)!=i ; j--) {   //(rLength-i-1)!=i针对只有一行的情况
                list.add(matrix[rLength-1-i][j]);
            }

            //从下到上打印
            for (int j = rLength-i-2; j >i && (cLength-i-1)!=i ; j--) {    //(cLength-i-1)!=i针对只有一列的情况
                list.add(matrix[j][i]);
            }
//        System.out.println(list.toString() + "**");
    }
        return list;
    }
}
编辑于 2019-05-21 11:23:19 回复(0)

花费了好长时间纳,,慢慢抠出来的。

矩阵分为

1. 偶数列,(使用通俗方法即可)

2. 奇数列中,偶数行(需要用长度限制)

3. 奇数列,奇数行 (需要补加)

上代码:

ArrayList list = new ArrayList(); int raw = matrix.length-1;//行 int col = matrix[0].length-1;//列  for (int m = 0,n =0 ;m1)/2+1&&n1)/2+1;m++,n++){ //需要循环多少圈   for (int i = m;i1)*(raw+1);i++){
        list.add(matrix[m][i]);  } for (int j = n;j1)*(raw+1);j++){
        list.add(matrix[j][col-n]);  } for (int i = col-m;i>m&&list.size()1)*(raw+1);i--){
        list.add(matrix[raw-m][i]);  } for (int j = raw-n;j>n&&list.size()1)*(raw+1);j--){
        list.add(matrix[j][n]);  }
} if ((col+1)%2==1&&(raw+1)%2==1&&raw==col){
    list.add(matrix[col/2][raw/2]); } return list; 

首先说下适应于常规操作的代码:

1. 通俗方法适应于偶数列的的矩阵,比如4*4,3*8之流的,完全没得问题

ArrayList list = new ArrayList(); int raw = matrix.length-1;//行 int col = matrix[0].length-1;//列  for (int m = 0,n =0 ;m1)/2+1&&n1)/2+1;m++,n++){ //需要循环多少圈   for (int i = m;i;i++){
        list.add(matrix[m][i]);  } for (int j = n;j;j++){
        list.add(matrix[j][col-n]);  } for (int i = col-m;i>m;i--){
        list.add(matrix[raw-m][i]);  } for (int j = raw-n;j>n;j--){
        list.add(matrix[j][n]);  }
} if ((col+1)%2==1&&(raw+1)%2==1&&raw==col){
    list.add(matrix[col/2][raw/2]); } return list; 

特殊的 奇数行 ,矩阵:3*3

代码是以画圈来进行顺时针获取数据的,比如:

123
456
789

左2(1,2)出来,
下2(3,6)出来,
右2(9,8)出来,
上2(7,4)出来。
由于长与宽均为3,实际只走一个圈,对于中间的唯一值5,我再最后进行了追加:

代码见下:

if ((col+1)%2==1&&(raw+1)%2==1&&raw==col){
            list.add(matrix[col/2][raw/2]);
        }

还有一种比较麻烦,因为它会重复画,针对于偶数行奇数列的矩阵,比如4*3;

此时我在4步中,均通过长度来判断是否继续循环。否则就会重复。

 for (int i = m;i<col-m&&list.size()<(col+1)*(raw+1);i++){
                list.add(matrix[m][i]);
            }
            for (int j = n;j<raw-n&&list.size()<(col+1)*(raw+1);j++){
                list.add(matrix[j][col-n]);
            }
            for (int i = col-m;i>m&&list.size()<(col+1)*(raw+1);i--){
                list.add(matrix[raw-m][i]);
            }
            for (int j = raw-n;j>n&&list.size()<(col+1)*(raw+1);j--){
                list.add(matrix[j][n]);
            }
发表于 2019-05-17 21:14:45 回复(0)
//idea from 剑指offer & debug参考BeACoder
//很多小细节会导致不能完全AC

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        
        ArrayList<Integer> result = new ArrayList<>();//用于保存输出序列
        if(matrix == null || matrix.length <= 0 )
            return  result;
        
        int row***atrix.length ;
        int col***atrix[0].length ;
        int start = 0;// start顺着对角线递增:0 1 2 ....所以每次的起始行,列坐标相同
        
        while(rows > 2*start && cols > 2*start)//循环条件???
        {
            printCircle(matrix, rows, cols, start,result);
            start++;
        }
       return result;
    }
    
    private void printCircle(int [][] matrix, int rows, int cols, int start, ArrayList<Integer> result){
        /*
         x = start 起始行号
         y = start 起始列号

         对角线右下角
         endRows = rows - 1 - start;
         endCols = cols - 1 - start;
        */
        
        int endCols = cols - 1 - start;
        int endRows = rows - 1 - start;
        
        //第1步:从左到右打印一行;总是需要的 get
        for(int i = start; i <= endCols; i++)
        {
            int number = matrix[start][i];
            result.add(number);
        }
        
        //第2步:从上到下打印一列;条件:终止行号大于起始行号
        if(start < endRows )
        {
            for(int i = start + 1; i <= endRows; i++)//明白为什么要+1
            {
                int number = matrix[i][endCols]; 
                result.add(number);
            }
        }
            
        //第3步:从右到左打印一行;条件:在第2步的基础上 + 终止列号小于起始列号
        if(start < endRows && start < endCols)
        {
            for(int i = endCols - 1; i >= start; i--)//明白为什么要-1
            {
                int number = matrix[endRows][i]; 
                result.add(number);
            }
        }
            
        //第4步:从下到上打印一列;条件:在第2步的基础上 + 在第3步的基础上 + 终止行号小于(起始的行号-1)说明中间至少还有一行
        if(start < endRows-1 && start < endCols )
        {
            for(int i = endRows - 1; i >= start + 1; i--)//明白为什么要+1:因为已经打印过了
            {
                int number = matrix[i][start]; 
                result.add(number);
            }
        }
    }
            
}


发表于 2019-05-17 17:32:36 回复(0)
  运行时间 : 33 ms 
//总体思路:
顺时针打印 = 循环打印 数组没有打印过的部分 的 最外围的一圈
用一个十进制的数表示数组的坐标,用一个set集合检验该点是否走过
public ArrayList<Integer> printMatrix(int [][] matrix) {
        Integer x = matrix[0].length;
        Integer y = matrix.length;
        Integer yLen = y.toString().length();
        if (x == y && y==0)
            return null;
        ArrayList<Integer> result = new ArrayList<>((int) ((x*y)/0.75));  //用来存结果的集合
        int row = 0, column = 0;                             //数组当前坐标
        Set<Double> entrys = new HashSet<>((int) ((x*y)/0.75));  //用来
        while (row > -1 && row < y && column > -1 && column < x &&      !entrys.contains(row*Math.pow(10,yLen)+column)) {
            while (column < x && !entrys.contains(row*Math.pow(10,yLen)+column)) {
                result.add(matrix[row][column]);
                entrys.add(row*Math.pow(10,yLen)+column);
                column ++;
            }
            column --;
            row ++;
            while (row < y && !entrys.contains(row*Math.pow(10,yLen)+column)) {
                result.add(matrix[row][column]);
                entrys.add(row*Math.pow(10,yLen)+column);
                row ++;
            }
            row --;
            column --;
            while (column > -1 && !entrys.contains(row*Math.pow(10,yLen)+column)) {
                result.add(matrix[row][column]);
                entrys.add(row*Math.pow(10,yLen)+column);
                column --;
            }
            column ++;
            row --;
            while (row > -1 && !entrys.contains(row*Math.pow(10,yLen)+column)) {
                result.add(matrix[row][column]);
                entrys.add(row*Math.pow(10,yLen)+column);
                row --;
            }
            row ++;
            column ++;
        }
        return result;
    }

发表于 2019-05-15 11:58:41 回复(0)
   public static ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        int i=0,j=0,N=matrix.length,M=matrix[0].length;
        int min=Math.min(N,M),k=0;
        for(k=0;k<min/2;k++) {
            i = j = k;
            for (; j < M - k; j++) {
                list.add(matrix[i][j]);
            }
            j--;
            list.remove(list.size() - 1);
            for (; i < N - k; i++) {
                list.add(matrix[i][j]);
            }
            i--;
            list.remove(list.size() - 1);
            for (; j >= k; j--) {
                list.add(matrix[i][j]);
            }
            j++;
            list.remove(list.size() - 1);
            for (; i >= k; i--) {
                list.add(matrix[i][j]);
            }
            i++;
            list.remove(list.size() - 1);
        }
        if( M==N && N%2!=0){
            list.add(matrix[min/2][min/2]);
        }
        if(M>N && N%2!=0){
            if(N==1){
                i=k;
            }else{
                i=N/2;
            }
            for(j=k;j<M-k;j++){
                list.add(matrix[i][j]);
            }
        }
        if(M<N && M%2!=0) {
            if(M==1){
                j=k;
            }else{
                j=M/2;
            }
            for(i=k;i<N-k;i++){
                list.add(matrix[i][j]);
            }
        }


        return list;
    }
编辑于 2019-05-13 09:42:42 回复(0)
设坐标为(x,y),顺时针打印,就是按照右(x,y+1) 、下(x+1,y)、 左(x,y-1)、 上(x-1,y)的顺序进行。
 这时候我们可以用两个一维数组来表示方向,dx[] = {0,1,0,-1} dy[] = {1,0,-1,0},然后 可以设置 一个方向d
,规定右(d=0)、下(d=1)、左(d=2)、上(d=3),按照这四个方向循环变化,即d取值为0,1,2,3,0,1,2,3,0.....
所以有当方向 发生变化的时候,d = (d+1)%4 。
而引起方向变化的条件有两个:
1.到达 边界
2.到达已经访问过的元素的边界(对于这一点我们可以 再开一个二维数组对访问过 的元素做标记)
代码如下:
 import java.util.ArrayList;
public class Solution {
    
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        
       ArrayList<Integer> result =  new ArrayList<>();
       if(matrix==null || matrix.length==0){
           return result;
       }
       int row = matrix.length;
       int col = matrix[0].length;
        
        boolean[][] visited =  new boolean[row][col];
       
       int dx[] = {0,1,0,-1};
       int dy[] = {1,0,-1,0};
        
       int x = 0,y=0,d=0;
       for(int i=0;i<row*col;i++){
         
           result.add(matrix[x][y]);
           visited[x][y] = true;
           
           int nx = x + dx[d];
           int ny = y + dy[d];
           
           if(nx<0 || nx>=row || ny<0 || ny>=col || visited[nx][ny]){
               d = (d+1)%4;
               nx = x + dx[d];
               ny = y + dy[d];
           }
          
           x = nx;
           y = ny;
           
            
       }
        
        return result;
        
 
        
    }
}

发表于 2019-05-07 09:53:12 回复(0)

按圈进行递归打印,注释打开然后把递归注释掉就是循环写法。

public static ArrayList<Integer> printMatrix(int [][] matrix) {

        //左上
        int tR = 0;
        int tC = 0;
        //右下
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;

        ArrayList<Integer> arrayList = new ArrayList<>();


        return printMatrix(matrix,arrayList,tR,tC,dR,dC);

}

private static ArrayList<Integer> printMatrix(int[][] matrix,  ArrayList<Integer> arrayList, int tR, int tC, int dR, int dC) {

        if (tC > dC || tR > dR){
            return arrayList;
        }
        //while (tC <= dC && tR <= dR){
        //说明只有一行
        if (tR == dR){
            for (int i = tC; i <= dC; i++) {
                arrayList.add(matrix[tR][i]);
            }
            return arrayList;
        }
        //说明只有一列
        if (tC == dC){
            for (int i = tR; i <= dR; i++) {
                arrayList.add(matrix[i][tC]);
            }
            return arrayList;
        }


        //其他情况
        for (int i = tC; i < dC; i++) {
            arrayList.add(matrix[tC][i]);
        }
        for (int i = tR; i < dR; i++) {
            arrayList.add(matrix[i][dC]);
        }
        for (int i = dC; i > tC; i--) {
            arrayList.add(matrix[dR][i]);
        }
        for (int i = dR; i > tR; i--) {
            arrayList.add(matrix[i][tC]);
        }

        tC++;
        tR++;
        dC--;
        dR--;
        //}
        printMatrix(matrix,arrayList,tR,tC,dR,dC);
        return arrayList;
}
发表于 2019-05-06 13:51:49 回复(0)
public ArrayList<Integer> printMatrix(int[][] matrix) {

    if (matrix == null || matrix.length == 0) {
        return null;
    }

    int r1 = 0;
    int r2 = matrix.length - 1;
    int c1 = 0;
    int c2 = matrix[0].length - 1;

    ArrayList<Integer> list = new ArrayList<Integer>();

    while (r1 <= r2 && c1 <= c2) {

        // 左到右
        for (int i = c1; i <= c2; i++) {
            list.add(matrix[r1][i]);
        }

        // 上到下
        for (int i = r1 + 1; i <= r2; i++) {
            list.add(matrix[i][c2]);
        }

        // 右到左
        if (r1 != r2) {
            for (int i = c2 - 1; i >= c1; i--) {
                list.add(matrix[r2][i]);
            }
        }

        // 下到上
        if (c1 != c2) {
            for (int i = r2 - 1; i > r1; i--) {
                list.add(matrix[i][c1]);
            }
        }

        r1++;
        c2--;
        r2--;
        c1++;
    }

    return list;
}
发表于 2019-05-04 10:38:13 回复(0)
指定行列首尾索引,索引范围内for遍历行列,每遍历一行或一列,相应首尾索引加1或减1,判断索引是否越界,越界break。
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> arr = new ArrayList<>();
        // 为直观体现,x,y模拟坐标系。
        int xstart = 0;
        int xend = matrix[0].length - 1;
        int ystart = 0;
        int yend = matrix.length - 1;

        while (true) {
            // 第一行
            if (xstart > xend) break;
            for (int i = xstart; i <= xend; i++)
                arr.add(matrix[ystart][i]);
            ystart++;
            // 最后一列
            if (ystart > yend) break;
            for (int i = ystart; i <= yend; i++)
                arr.add(matrix[i][xend]);
            xend--;
            // 最后一行
            if (xstart > xend) break;
            for (int i = xend; i >= xstart; i--)
                arr.add(matrix[yend][i]);
            yend--;
            // 第一列
            if (ystart > yend) break;
            for (int i = yend; i >= ystart; i--)
                arr.add(matrix[i][xstart]);
            xstart++;
        }
        return arr;
    }
}


发表于 2019-05-02 10:05:27 回复(0)

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList();
        if (matrix == null || matrix.length == 0) {
            return list;
        }
        int rows = matrix.length;
        int columns = matrix[0].length;
        if (columns == 1) {
            for (int i = 0; i < rows; i++) {
                list.add(matrix[i][0]);
            }
            return list;
        }
        for (int i = 0; i < Math.ceil(rows / 2.0); i++) {
            //从左到右
            for (int j = i; j < columns - i; j++) {
                list.add(matrix[i][j]);
            }
            if (rows - i > i + 1 && i + 1 < columns) {
                //从上到下
                for (int j = i + 1; j < rows - 1 - i ; j++) {
                    list.add(matrix[j][columns - 1 - i]);
                }
                //从右到左
                for (int j = columns - 1 - i; j >= i ; j--) {
                    list.add(matrix[rows - 1 - i][j]);
                }
                //从下到上
                for (int j = rows - 1 - i - 1; j > i ; j--) {
                    list.add(matrix[j][i]);
                }
            }
        }
        return list;
    }
}

发表于 2019-04-30 22:58:17 回复(0)
//粗暴式解法,先x循环一圈得到外围一圈的数,再copy剩下的数组递归即可
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
         ArrayList<Integer> array=new ArrayList<Integer>();
          addList(matrix,array); 
        return array;
    }
     public void addList(int [][] matrix,ArrayList<Integer> array) {
          if(matrix==null) {
              return;
          }
          int row=matrix[0].length;
          int col=matrix.length;
          if(row==0) {
              return;
          }
                //四个小循环得到外围数据,注意row=1或者col=1情况下的重复读取
          for(int i=0;i<row;i++) {
                 array.add(matrix[0][i]);
             }
             for(int i=1;i<col;i++) {
                 array.add(matrix[i][row-1]);
             }
             if(col>1) {
             for(int i=row-2;i>=0;i--) {
                 array.add(matrix[col-1][i]);
             }
             }
             if(row>1) {
             for(int i=col-2;i>0;i--) {
                 array.add(matrix[i][0]);
             }
             }
                    //复制剩余数组
             if(col>2&&row>2) {
             int[][] copy = new int[col-2][row-2];
              for(int i=1;i<=row-2;i++) {
                  for(int j=1;j<=col-2;j++) {
                      copy[j-1][i-1]=matrix[j][i];
                  }
              }
                        //递归
              addList(copy,array);
             }
      }
} 

发表于 2019-04-22 18:38:42 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList();
        if(matrix==null || matrix.length<1 || matrix[0].length<1) return list;
        int row = matrix.length-1;
        int col = matrix[0].length-1;
        int i=0,j=0;
        while( i<=row && j<=col){
            print(list,matrix,i++,row--,j++,col--);
        }
        return list;
    }
    // 每一圈具体打印方法
    public void print(ArrayList<Integer> list,int[][] matrix,int rowStart,int rowEnd,int colStart,int colEnd){
        if(rowStart==rowEnd){  // 只剩一行
            for(int i=colStart;i<=colEnd;i++) list.add(matrix[rowStart][i]);
        } else if(colStart==colEnd){  // 只剩一列
            for(int i=rowStart;i<=rowEnd;i++) list.add(matrix[i][colStart]);
        }else{
            // 打印最上面一行 除去最右边的数
            for(int i=colStart;i<colEnd;i++) list.add(matrix[rowStart][i]);
            // 打印最右边一列 除去最下面的数
            for(int i=rowStart;i<rowEnd;i++) list.add(matrix[i][colEnd]);
            // 逆序打印最下边一行 除去最左边的数
            for(int i=colEnd;i>colStart;i--) list.add(matrix[rowEnd][i]);
            // 逆序打印最左一列 除去最上面的数
            for(int i=rowEnd;i>rowStart;i--) list.add(matrix[i][colStart]);
        }
    }
}
发表于 2019-04-21 14:56:09 回复(0)