首页 > 试题广场 > 顺时针打印矩阵
[编程题]顺时针打印矩阵
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下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.
推荐
/*解题思路:顺时针打印就是按圈数循环打印,一圈包含两行或者两列,在打印的时候会出现某一圈中只包含一行,要判断从左向右打印和从右向左打印的时候是否会出现重复打印,同样只包含一列时,要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/
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 回复(47)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0){
            return new ArrayList<>();
        }
        //左上角(a,b)
        int a = 0;
        int b = 0;
        //右下角(c,d)
        int c = matrix.length - 1;
        int d = matrix[0].length - 1;
        ArrayList<Integer> list = new ArrayList<>();
        int i;

        //左上角和右下角这两个点不断向中间靠拢
        //当左上角的行在右下角的行下面时跳出循环
        //当左上角的列在右下角的列右面时跳出循环
        while(a <= c && b <= d){
            //打印第一行
            for(i = b; i <= d; i++){
                list.add(matrix[a][i]);
            }
            //当只有一行的时候,说明此时已经打印完毕,需要跳出
            if(++a > c){
                break;
            }
            //打印最后一列
            for(i = a; i <= c; i++){
                list.add(matrix[i][d]);
            }
            //当只有一列的时候,说明此时已经打印完毕,需要跳出
            if(--d < b){
                break;
            }
            //打印最后一行
            for(i = d; i >= b; i--){
                list.add(matrix[c][i]);
            }
            c--;
            //打印第一列
            for(i = c; i >= a; i--){
                list.add(matrix[i][b]);
            }
            b++;
        }
        return list;
    }

}
发表于 2019-08-18 18:19:54 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList();
        if(matrix==null || matrix[0]==null)
            return list;
        int row = matrix.length-1;
        int col = matrix[0].length-1;
        int cr = 0;
        int cc = 0;
        while(cr <= row && cc <= col) {
            printEdge(matrix,list,cr++,cc++,row--,col--);
            //row--,col--右下边界越来越小,cr++,cc++左上边界越来越大,使得圈变小
        }
        return list;
    }
    
    void printEdge(int [][] matrix,ArrayList list,int cr,int cc,int row,int col) {
        if(cr == row) {
            for(int i=cc;i<=col;i++) {
                list.add(matrix[cr][i]);
            }
        } else if(cc == col) {
            for(int j=cr;j<=row;j++) {
                list.add(matrix[j][cc]);
            }
        } else {
            int r = cr,c = cc;
            while(c!=col) {
                list.add(matrix[cr][c]);
                c++;
            }
            while(r!=row) {
                list.add(matrix[r][c]);
                r++;
            }
            while(c!=cc) {
                list.add(matrix[r][c]);
                c--;
            }
            while(r!=cr) {
                list.add(matrix[r][c]);
                r--;
            }
        }
    }
}

发表于 2019-08-16 20:49:55 回复(0)
import java.util.ArrayList;

/**
 * 思路:
 * 1.写四个遍历方法
 * 2.设定上下左右边界值
 * 3. 每次走循环的时候的时候都要判断 left <= right && top <= below,while判断条件同样是这个!(left,左边界,right右边界,top上边界,below下边界)
 */
public class Solution {
    public ArrayList<Integer> printMatrix(int[][] a) {
        ArrayList<Integer> arrayList = new ArrayList<>();

            int left = 0;
            int right = a[0].length - 1;
            int top = 0;
            int below = a.length - 1;
            while (left <= right && top <= below) {
                if (left <= right && top <= below) {
                    left2right(a, left, right, top, arrayList);
                    top++;
                }
                if (left <= right && top <= below){
                    top2below(a, top, below, right, arrayList);
                    right--;
                }
               if (left <= right && top <= below){
                   right2left(a, left, right, below, arrayList);
                   below--;
               }
               if (left <= right && top <= below){
                   below2top(a, top, below, left, arrayList);
                  left++;
               }

            }

        return arrayList;

    }

    //从左到右
    public static void left2right(int[][] a, int left, int right, int row, ArrayList<Integer> arrayList) {
        for (int i = left; i <= right; i++) {
            arrayList.add(a[row][i]);
        }
    }

    //从右到左
    public static void right2left(int[][] a, int left, int right, int row, ArrayList<Integer> arrayList) {
        for (int i = right; i >= left; i--) {
            arrayList.add(a[row][i]);
        }
    }

    //从上到下
    public static void top2below(int[][] a, int top, int below, int col, ArrayList<Integer> arrayList) {
        for (int i = top; i <= below; i++) {
            arrayList.add(a[i][col]);
        }
    }


    //从下到上
    public static void below2top(int[][] a, int top, int below, int col, ArrayList<Integer> arrayList) {
        for (int i = below; i >= top; i--) {
            arrayList.add(a[i][col]);
        }
    }
}
发表于 2019-08-13 05:06:30 回复(0)
package test;

import java.util.ArrayList;
import java.util.Scanner;

public class MyTreeNode {
	public static void main(String[] args) {
		MyTreeNode m = new MyTreeNode();
		int[][] a = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 } };
		ArrayList<Integer> aa = m.printMatrix(a);
		System.out.println(aa.toString());
	}

	public ArrayList<Integer> printMatrix(int[][] matrix) {
		Scanner in = new Scanner(System.in);
		int maxCol = matrix[0].length;
		int maxRow = matrix.length;
		ArrayList a = new ArrayList();
		int minCol = 0;
		int minRow = 0;
		int size = maxCol * maxRow;
		int row = 0;
		int col = 0;
		int flag = 0;
		for (int i = 0; i < size; i++) {
			a.add(matrix[row][col]);
			switch (flag % 4) {
			case 0:
				col++;
				if (col >= maxCol) {
					col--;
					flag++;
					row++;
					minRow++;
				}
				break;

			case 1:
				row++;
				if (row >= maxRow) {
					row--;
					flag++;
					col--;
					maxCol--;
				}
				break;

			case 2:
				col--;
				if (col < minCol) {
					col++;
					flag++;
					row--;
					maxRow--;
				}
				break;

			case 3:
				row--;
				if (row < minRow) {
					row++;
					flag++;
					col++;
					minCol++;
				}
				break;
			}
		}
		return a;
	}
}

发表于 2019-08-12 16:40:06 回复(0)
import java.util.ArrayList;

/**
 * @description:    面试题29:顺时针打印矩阵
 * @author: Dafengsu
 * @date: 2019/8/7
 */
public class PrintMatrix {
    public ArrayList<Integer> printMatrix(int[][] matrix) {
        //如果矩阵为空,矩阵内容为空,直接返回null
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return null;
        }
        //矩阵列数
        int rows = matrix.length;
        //矩阵行数
        int columns = matrix[0].length;
        //循环打印的起始点:(0,0),(1,1),(2,2)等等
        int start = 0;
        //创建链表接收数据
        ArrayList<Integer> res = new ArrayList<>();
        //只有在列数和函数都满足要求的情况下,才可以继续循环,打印起始点的
        //横纵坐标都不能超过数组横纵长度的一半
        while (columns > start * 2 && rows > start * 2) {
            //转圈打印
            printMatrixInCircle(matrix, columns, rows, start, res);
            //起始点向右下移动
            start++;
        }
        return res;
    }

    /**
     * 旋转输出数据
     * @param matrix    数组
     * @param columns   数组列数
     * @param rows      数组行数
     * @param start     打印起始点
     * @param res       结果
     */
    private void printMatrixInCircle(int[][] matrix, int columns, int rows, int start, ArrayList<Integer> res) {
        //打印的横坐标终点
        int endX = columns - 1 - start;
        //打印的纵坐标终点
        int endY = rows - 1 - start;
        //从左到右输出
        for (int i = start; i <= endX; i++) {
            res.add(matrix[start][i]);
        }
        //从上到下输出(继续向下打印的条件是,起始点的纵坐标要大于终点纵坐标,既这个圈至少有两行)
        if (start < endY) {
            for (int i = start + 1; i <= endY; i++) {
                res.add(matrix[i][endX]);
            }
        }
        //从左到右输出(继续向右打印的条件是,起始点的横坐标要小于终点横坐标,同时满足
        //起始点的纵坐标要小于终点的纵坐标,既当前圈至少有两行两列)
        if (start < endX & start < endY) {
            for (int i = endX - 1; i >= start; i--) {
                res.add(matrix[endY][i]);
            }
        }
        //从下到上输出(继续大于的条件是,起始点的横坐标要小于终点横左标,同时满足
        //起点纵坐标要小于终点纵坐标-1,既当前圈至少要两行三列)
        if (start < endX && start < endY - 1) {
            for (int i = endY - 1; i >= start + 1; i--) {
                res.add(matrix[i][start]);
            }
        }
    }
}

发表于 2019-08-08 00:29:36 回复(0)
/*先打印第一行的数组元素,然后保存删除第一行后的数组,再逆时针旋转90°,如此往复,递归求出最后结果*/
public class Solution {
    ArrayList<Integer> arrayList=new ArrayList<Integer>();
    public ArrayList<Integer> printMatrix(int [][] matrix) 
    {
        if(matrix==null)return arrayList;
        int n=matrix.length;//矩阵的行数
        int m=matrix[0].length;//矩阵的列数
        if(n>=1&&m==1)
        {
            for(int i=0;i<n;i++)
            {
                arrayList.add(matrix[i][m-1]);
            }
            return arrayList;
        }
        if(n==1&&m>=1)
        {
            for(int i=0;i<m;i++)
            {
                arrayList.add(matrix[n-1][i]);
            }
            return arrayList;
        }
        for(int j=0;j<m;j++)
        {
            arrayList.add(matrix[0][j]);
        }
        int[][] mat=new int[n-1][m];
        for(int i=0;i<n-1;i++)
        {
            for(int j=0;j<m;j++)
            {
                mat[i][j]=matrix[i+1][j];
            }
        }
        int[][] xuanzhuan=Rotation(mat, n-1, m);
        return printMatrix(xuanzhuan);
    }
    public int[][] Rotation(int[][] mat,int n,int m)//逆时针旋转90度
    {
        int[][] a=new int[m][n];
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                a[i][j]=mat[j][m-i-1];
            }
        }
        return a;
    }
    public static void main(String[] args)
    {
        int[][] a= {{1,2,3},{4,5,6},{7,8,9}};
        Solution solution=new Solution();
        Iterable<Integer> z=new ArrayList<Integer>();
        z=solution.printMatrix(a);
        System.out.println("*********************");
        System.out.println("打印完整的arraylist元素:");
        for(int x:z)
        {
            System.out.print(x+" ");
        }
        System.out.println();
    }
}


发表于 2019-08-04 11:05:20 回复(0)
import java.util.ArrayList;
public class Solution {
    
    /*思路为递归处理*/
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer>arrayList=new ArrayList<Integer>();
        int rows=matrix.length-1;//行数
        int columns=matrix[0].length-1;//列数
        /*数组为空或为null则直接返回,保证数组中有数据*/
        if(rows==-1||matrix==null) return arrayList;
        if(rows==0||columns==0) {/*单行单列*/
            if(rows==0) {//单行
                for (int i = 0; i <=columns; i++) {
                    arrayList.add(matrix[0][i]);
                }
            }else {//单列
                for (int i = 0; i <=rows; i++) {
                    arrayList.add(matrix[i][0]);
                }
            }
            
        }else {/*多行多列*/
             A(arrayList, matrix, 0, rows, 0, columns);
        }
       
        return arrayList;
    }
    /*多行多列进行递归处理*/
    public   void A(ArrayList<Integer> arrayList,int[][]matrix,int r1,int r2,int c1,int c2) {
        if(r2<r1||c2<c1) return;
         
            boolean flage1 = false,flage2=false,flage3=false;
            /*下述的所有if作用是为了给flage赋值,避免在多重循环中对flage赋值*/
            if(c1<=c2) {
                flage1=true;
                for (int i1 = c1; i1 <=c2; i1++) {/*从左到右*/
                    arrayList.add(matrix[r1][i1]);
                }
            }
            if((r1+1)<=r2&&flage1) {
                flage2=true;
                for (int j1 = r1+1; j1 <=r2; j1++) {/*从上到下*/
                    arrayList.add(matrix[j1][c2]);
                }
            }
            if((c2-1)>=c1&&flage2) {
                flage3=true;
                for (int i2 =c2-1; i2 >= c1; i2--) {/*从右到左*/
                    arrayList.add(matrix[r2][i2]);
                }
            }
            if(flage3) {
                for (int j2 = r2-1; j2>=r1+1; j2--) {/*从下到上*/
                    arrayList.add(matrix[j2][c1]);
                }
            }
            
            
            A(arrayList, matrix, r1+1, r2-1, c1+1, c2-1);
         
        }
        
    
}
发表于 2019-08-01 16:23:59 回复(0)
public class Solution {
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        //ArrayList list = new ArrayList();
        int currentRow = matrix.length;    //当前的行数
        int currentCol = matrix[0].length; //当前的列数
        
        if(matrix == null){
            return null;
        }
        //一行(包括一格)
        if(currentRow == 1){
            oneRowAdd(matrix,list);
        }else if(currentCol == 1 && currentRow != 1){    //一列
            oneColAdd(matrix,list);
        }else{//>= 两行 或 两列
            someAdd(matrix,list);
            currentRow = currentRow - 2;
            currentCol = currentCol -2 ;
            //int [][] sMatrix = narrow(matrix);
            if(currentRow >=1 && currentCol >=1){
                int [][] sMatrix = narrow(matrix);
                printMatrix(sMatrix);
            }
        }
        
        return list;

    }
    
    //1行add 包括一格
    public void oneRowAdd(int [][] matrix, ArrayList<Integer> list){
        //一行(包括一格)
        //if(matrix.length == 1){
            for(int i=0; i<matrix[0].length; i++)
                list.add(matrix[0][i]);
            //return list;
    }
    
    //1列add
    public void oneColAdd(int [][] matrix, ArrayList<Integer> list){
        for(int i=0; i<matrix.length; i++)
            list.add(matrix[i][0]);
        //return list;
    }
    
    // >= 两行 或 两列
    public void someAdd(int [][] matrix, ArrayList<Integer> list){
        for(int i=1; i<matrix[0].length; i++)
            list.add(matrix[0][i-1]);
        for(int i=1; i<matrix.length; i++)
            list.add(matrix[i-1][matrix[0].length-1]);
        for(int i=matrix[0].length; i>1; i--)
            list.add(matrix[matrix.length-1][i-1]);
        for(int i=matrix.length; i>1; i--)
            list.add(matrix[i-1][0]);
            
        //return list;
    }
    
    //narrow 用于缩小矩阵
    public int[][] narrow(int[][] arr){
        int[][] sArr = new int [arr.length-2][arr[0].length-2];
        for(int i=0; i<sArr.length; i++){
            for(int j=0; j<sArr[0].length; j++){
                sArr[i][j] = arr[i+1][j+1];
            }
        }
        return sArr;
    }
    
}


发表于 2019-07-31 16:49:12 回复(0)

public ArrayList<Integer> printMatrix(int [][] matrix) {
    //顺时针打印也就是绕个圈嘛,也就四种状态,向右向下向左向上,依次循环
    //根据状态以及是否达到边界来更改状态以及修改边界,以count计数作为循环终止条件
    ArrayList<Integer> list = new ArrayList<>();  if (matrix == null)
    {  return null;
    }  int a = matrix[0].length, b = matrix.length, count = 0, i = 0, j = 0;  int num = a*b;  int side1 = a - 1, side2 = b - 1, side3 = 0, side4 = 1;  int change1 = 0, change2 = 1;  while(count!=num)
    {
        list.add(matrix[i][j]);  if(change1 == 0 && change2 == 1 && j == side1)
        {
            change1 = 1;
            change2 = 0;
            side1 = side1 - 1;
        }  else if(change1 == 1 && change2 == 0 && i == side2)
        {
            change1 = 0;
            change2 = -1;
            side2 = side2 - 1;
        }  else if(change1 == 0 && change2 == -1 && j == side3)
        {
            change1 = -1;
            change2 = 0;
            side3 = side3 + 1;
        }  else if(change1 == -1 && change2 == 0 && i == side4)
        {
            change1 = 0;
            change2 = 1;
            side4 = side4 + 1;
        }
        i = i + change1;
        j = j + change2;
        count++;
    } return list;
}


编辑于 2019-07-31 09:34:08 回复(0)
自己搞了个剥洋葱算法 一层一层剥掉外面的一圈。。。。稀里糊涂过了

import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> temp = new ArrayList<>();
    public ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<ArrayList<Integer>> onions = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < matrix.length; i++) {
            ArrayList<Integer> columnList = new ArrayList<Integer>();
            for (int j = 0; j < matrix[i].length; j++) {
                columnList.add(j, matrix[i][j]);
            }
            onions.add(i, columnList);
        }
        PeelingOnions(onions);
        return temp;
    }
    //剥洋葱算法
    public void PeelingOnions(ArrayList<ArrayList<Integer>> onions) {
        if (onions.isEmpty()) {
            return;
        }
        //将最上面一行值放进去然后剥掉这一行
        temp.addAll(onions.get(0));
        onions.remove(0);
        //放入右侧一列并剥掉
        if (onions.size() > 0&& (!onions.get(0).equals(new ArrayList<>()))) {
            for (int i = 0; i < onions.size(); i++) {
                //获取每行最后一个
                temp.add(onions.get(i).get(onions.get(i).size() - 1));
                //剥掉最后一个
                onions.get(i).remove(onions.get(i).size() - 1);
            }
        }
        if (onions.size() > 0 && (!onions.get(0).equals(new ArrayList<>()))) {
            for (int i = onions.get(onions.size() - 1).size() - 1; i >= 0; i--) {
                //获取最后一行倒序
                temp.add(onions.get(onions.size() - 1).get(i));
            }
        }
        //删掉
        if (onions.size() > 0 && (!onions.get(0).equals(new ArrayList<>()))) {
            onions.remove(onions.size() - 1);
        }
        //左侧一列 加入
        if (onions.size() > 0 && (!onions.get(0).equals(new ArrayList<>()))) {
            for (int i = onions.size() - 1; i >= 0; i--) {
                //倒叙获取第一列
                temp.add(onions.get(i).get(0));
                //剥掉
                onions.get(i).remove(0);
            }
        }
        //剥完了 递归继续剥到没有为止
        PeelingOnions(onions);
    }
}


编辑于 2019-07-30 23:06:11 回复(0)
import java.util.ArrayList;
public class Solution {
    
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        
        ArrayList  list=new ArrayList(); 
        int row=0, 
            line=0,
            rmax = matrix.length-1,
            lmax = matrix[0].length-1;
        while( row <= rmax && line <= lmax){
            addlop(list, matrix, row++, line++, rmax--, lmax--);
        }
        return list;
    }
    public void addlop( ArrayList list, int[][] matrix, int row, int line, int rmax, int lmax){
        
        if( row == rmax  ){
            while( line <= lmax)list.add( matrix[row][line++]);
        }else if( line == lmax){
            while( row <= rmax)list.add( matrix[row++][line]);
        }else{
            int i = row, 
                j = line;
            while( j<lmax)list.add( matrix[row][j++] );
            while( i < rmax)list.add( matrix[i++][lmax] );
            while( j > line)list.add( matrix[rmax][j--] );
            while( i > row )list.add( matrix[i--][line] );
        }
    }
}

发表于 2019-07-30 18:47:18 回复(0)

一道看起来简单,做起来费时费力的题!
主要问题是很容易漏掉东西,仔细点就好了。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int row = matrix.length;
        int col = 0;
        if(row != 0)
            col = matrix[0].length;
        ArrayList<Integer> list = new ArrayList<Integer>();
        //先把四边存一遍
        for(int i = 0; i <= col-1; i++)
            list.add(matrix[0][i]);
        for(int i = 1; i < row-1; i++)
            list.add(matrix[i][col-1]);
        if(row-1 > 0)
            for(int i = col-1; i >= 0; i--)
                list.add(matrix[row-1][i]);
        if(col-1 > 0)
            for(int i = row-2; i > 0; i--)
                list.add(matrix[i][0]);
        //如果是一个大于2 X 2的矩阵,则内部存在小矩阵
        if(row>2&&col>2){
            int[][] next = new int[row-2][col-2];
            for(int i = 1; i < row-1; i++){
                for(int j = 1; j < col-1; j++)
                    next[i-1][j-1]=matrix[i][j];
            }
            //把内部小矩阵的数据存一遍
            list.addAll(printMatrix(next));
        }
        return list;
    }
}
发表于 2019-07-25 16:37:07 回复(0)
//暴力破解法
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> arr = new ArrayList<>();
        int rowNum = matrix.length;
        int colNum = matrix[0].length;
        int rowF = 0;
        int colF = 0;
        int i = 0,j = 0;
        while(rowF<rowNum&&colF<colNum){
            while(rowF<rowNum&&colF<colNum&&j<colNum){
                arr.add(matrix[i][j]);
               // System.out.print(matrix[i][j]);
                j++;
            }
            rowF++;
            j--;
            i++;
            while(rowF<rowNum&&colF<colNum&&i<rowNum){
                arr.add(matrix[i][j]);
              //  System.out.print(matrix[i][j]);
                i++;
            }
            colNum--;
            i--;
            j--;
            while(rowF<rowNum&&colF<colNum&&j>=colF){
                arr.add(matrix[i][j]);
              //  System.out.print(matrix[i][j]);
                j--;
            }
            j++;
            rowNum--;
            i--;
            while(rowF<rowNum&&colF<colNum&&i>=rowF){
                arr.add(matrix[i][j]);
               // System.out.print(matrix[i][j]);
                i--;
            }
            i++;
            j++;
            colF++;
        }
        return arr;
    }
}

发表于 2019-07-24 16:57:55 回复(0)
   public static ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result=new ArrayList<Integer>();
        if(matrix==null||matrix.length==0) return result;
        int matrix_hang=matrix.length;
        int matrix_lie=matrix[0].length;
        int i=0;//第i圈
        //一圈一圈走
        while((matrix_hang-2*i)>0&&(matrix_lie-2*i)>0){
            for(int j=i;j<matrix_lie-i;j++)     result.add(matrix[i][j]);//->方向移动
            for(int j=i+1;j<matrix_hang-i;j++)  result.add(matrix[j][matrix_lie-1-i]);//往下移动
            if(i!=(matrix_hang-1-i)){
                for(int j=matrix_lie-2-i;j>=i;j--) result.add(matrix[matrix_hang-1-i][j]);//往左移动
            }
            if(i!=(matrix_lie-1-i)) {
                for (int j = matrix_hang - 2 - i; j > i; j--) result.add(matrix[j][i]);//往上移动,移完一圈
            }
            i++;
        }
        return result;
    }
编辑于 2019-07-17 13:46:01 回复(0)
import java.util.ArrayList;

public class Solution{
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int rows = matrix.length;
        int columns = matrix[0].length;
        int start = 0;
        while(rows > start*2 && columns > start*2){
            printMatrixInCircle(matrix, rows, columns, start);
            start++;
        }
        return list;
    }
    /**
     * 功能:打印一圈
     */
    public void printMatrixInCircle(int [][] matrix, int rows, int columns, int start){
        int endx = columns-1-start;//终止列号
        int endy = rows-1-start;//终止行号
        // 从左到右打印一行
        for(int i = start; i <= endx; i++)
            list.add(matrix[start][i]);
        
        // 从上到下打印一列
        if(start<endy){//终止行大于起始行号:1<2
            for(int j = start + 1; j < rows - start; j++)
                list.add(matrix[j][endx]);
        }
        
        // 从右到左打印一行
        if(start<endy&&start<endx){
            for(int m = endx-1; m >= start; m--)
                list.add(matrix[endy][m]);
        }
        
        // 从下到上打印一列
        if(start<endx&&start<endy-1){//终止列大于起始列且终止行与起始行最少隔一行
            for(int n = endy-1; n >= start + 1; --n)
                list.add(matrix[n][start]);
        }
    }
}

发表于 2019-07-14 18:34:34 回复(0)
import java.util.ArrayList;

public class Solution {


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

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

        int tR = 0;
        int tC = 0;
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;
        while (tR <= dR && tC <= dC) {
            addMatrix(matrix, tR++, tC++, dR--, dC--, result);
        }
        return result;
    }

    public static void addMatrix(int[][] matrix, int tR, int tC, int dR, int dC, ArrayList<Integer> result) {

        if (tR == dR) {
            while (tC <= dC) {
                result.add(matrix[tR][tC++]);
            }
        } else if (tC == dC) {
            while (tR <= dR) {
                result.add(matrix[tR++][tC]);
            }
        } else {
            int curC = tC;
            int curR = tR;
            while (curC != dC) {
                result.add(matrix[tR][curC++]);
            }
            while (curR != dR) {
                result.add(matrix[curR++][dC]);
            }
            while (curC != tC) {
                result.add(matrix[dR][curC--]);
            }
            while (curR != tR) {
                result.add(matrix[curR--][tC]);
            }
        }
    }
}
发表于 2019-07-01 23:38:53 回复(0)
设置4个转折点   他们分别是左上,左下,右上,右下
每到一个转折点就使数据流动方向更改
flag为1,2,3,4四种流动方向
ArrayList<Integer> arrayList = new ArrayList<>(); int chang = matrix[0].length - 1; int kuan = matrix.length - 1; int l = (chang + 1) * (kuan + 1); int i = 0, j = 0; int k = 0; int flag=1; int youshang1=0; //右上角的转折点坐标 int youshang2=chang; //右上角的转折点坐标 int youxia1=kuan; int youxia2=chang; int zuoxia1=kuan; int zuoxia2=0; int zuoshang1=1; int zuoshang2=0; while (k != l) {
    System.out.print("  ["+i+"]"+"["+j+"]"+matrix[i][j]);  k++;  if (i==youshang1&&j==youshang2){ //进入右上的转折点  使数据向下流动  flag=2;  } if (i==youxia1&&j==youxia2){ //进入坐下的转折点  使数据项左流动  flag=3;  } if (i==zuoxia1&&j==zuoxia2){ //向上流动  flag=4;  } if (i==zuoshang1&&j==zuoshang2){ //向左流动      并且重置4个转折点  youshang1++;  youshang2--;  youxia1--;  youxia2--;  zuoxia1--;  zuoxia2++;  zuoshang1++;  zuoshang2++;  flag=1;  } if (kuan==0){ //如果数组宽是1 始终向右流动  flag=1;  } if(chang==0){ //如果数组长是1 始终向下流动  flag=2;  } if (flag==1)
        j++;  if (flag==2)
        i++;  if (flag==3)
        j--;  if (flag==4)
        i--; } return arrayList;

编辑于 2019-07-01 03:51:30 回复(0)

通过举例,追踪打印过程中索引的变化规律,自创挡泥板法,完成顺时针打印矩阵。

public class _29_PrintMatrix {
    /**
     * 挡泥板法:
     *  - - - - - -
     * |            |
     * |            |
     * |            |
     *  - - - - - -   
     * 通过四块挡泥板辅助完成顺时针循环打印矩阵,
     * i 挡泥板:水平放置,控制打印时上下波动的范围,iLowBoundary, iHighBoundary;
     * j 挡泥板:竖直放置,控制打印时左右波动的范围,jLowBoundary, jHighBoundary;
     * 通过判断打印的数目是否等于矩阵中的所有元素,判断是否结束打印。
     * 逻辑清晰,可编程性高,时间复杂度 O(n)
     * @param matrix
     * [@return](/profile/547241) */
    public ArrayList printMatrix(int [][] matrix) {
        ArrayList res = new ArrayList();
        if (matrix == null)
            return res;
        int iLowBoundary = 0;
        int jLowBoundary = 0;
        int iHighBoundary = matrix.length-1;
        int jHighBoundary = matrix[0].length-1;
        int hasPrintNum = 0;
        int total = (iHighBoundary+1)*(jHighBoundary+1);
        while (hasPrintNum < total) {
            for (int i = iLowBoundary, j = jLowBoundary; j <= jHighBoundary && hasPrintNum < total; j++) {
                res.add(matrix[i][j]);
                hasPrintNum++;
            }
            iLowBoundary++;
            for (int i = iLowBoundary, j = jHighBoundary; i <= iHighBoundary && hasPrintNum < total; i++) {
                res.add(matrix[i][j]);
                hasPrintNum++;
            }
            jHighBoundary--;
            for (int i = iHighBoundary, j = jHighBoundary; j >= jLowBoundary && hasPrintNum < total; j--) {
                res.add(matrix[i][j]);
                hasPrintNum++;
            }
            iHighBoundary--;
            for (int i = iHighBoundary, j = jLowBoundary; i >= iLowBoundary && hasPrintNum < total; i--) {
                res.add(matrix[i][j]);
                hasPrintNum++;
            }
            jLowBoundary++;
        }
        return res;
    }
    public static void main(String[] args) {
        _29_PrintMatrix solution = new _29_PrintMatrix();
        int[][] matrix = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}};
        int[][] matrix1 = {{1}, {2}, {3}, {4}, {5}};
        System.out.println(solution.printMatrix(matrix1));
    }
}
编辑于 2019-06-28 15:31:26 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        // 结果集合
        ArrayList<Integer> result = new ArrayList<>();
        // 列数
        int col = matrix[0].length;
        while(col >= 1) {
            // 取第一行加入结果
            for(int i = 0; i < col; i++) {
                result.add(matrix[0][i]);
            }
            // 获得新矩阵的列数
            matrix = getNewMatrix(matrix);
            col = matrix[0].length;
        }
        
        return result;
        
    }
    
    // 旋转获得新的矩阵
    private int[][] getNewMatrix(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        // 已经减少了一行
        int[][] newMatrix = new int[col][row - 1];
        
        for(int j = col - 1; j >= 0; j--) {
            for(int i = 1; i < row; i++) {
                newMatrix[col - 1 - j][i - 1] = matrix[i][j];
            }
        }
        
        return newMatrix;
    }
}
发表于 2019-06-26 20:05:59 回复(0)
//用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)