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

213个回答

添加回答
推荐
/*解题思路:顺时针打印就是按圈数循环打印,一圈包含两行或者两列,在打印的时候会出现某一圈中只包含一行,要判断从左向右打印和从右向左打印的时候是否会出现重复打印,同样只包含一列时,要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/
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 回复(42)
public static ArrayList<Integer> printMatrix(int [][] matrix) {
        int col  = matrix[0].length;
        int row = matrix.length;
        ArrayList<Integer> list = new ArrayList<Integer>();
        //1,如果矩阵的行数或者列数小于2,绕一圈就可以遍历完所有的元素
        if(row == 1 || col== 1)
        {   //1.1 当矩阵只是一行元素 或者 
            if(col > 1) {
                for (int i = 0; i < col; i++)
                    list.add(matrix[0][i]);
            }// 只是一列元素,直接想它们添加到ArrayList
            else if(row > 1) {
                for (int i = 0; i < row; i++)
                    list.add(matrix[i][0]);
        }//1.2当矩阵只是一个数
            else {
                list.add(matrix[0][0]);
            }
        }
        // 2.当行数或者列数等于大于2,遍历外围一圈的元素,将它们按顺序添加到ArrayList
        else if(row >= 2|| col >=2) {
            for (int i = 0; i < col; i++) {
                list.add(matrix[0][i]);
            }
            for (int j = 1; j < row; j++) {
                list.add(matrix[j][col - 1]);
            }
            for (int i = col - 2; i >= 0; i--) {
                list.add(matrix[row - 1][i]);
            }
            for (int j = row - 2; j >= 1; j--) {
                list.add(matrix[j][0]);
            }
        }
        //如果行数或者列数大于2,遍历一次外围的元素后,里面还有元素没遍历到,需要将里面的元素提取到一个新的矩阵
        if(row>2 && col>2)
        {//因为矩阵的维数不确定性,采用一个函数定义矩阵
            int[][] new_matrix = defineMtrix(row, col);
            for (int i = 1; i < row - 1; i++) {
                for (int j = 1; j < col - 1; j++) {
                    new_matrix[i - 1][j - 1] = matrix[i][j];
                }
            }//新的矩阵再继续递归遍历外围元素
            list.addAll(printMatrix(new_matrix));
        }
        return list;

    }
    private static int[][] defineMtrix(int row, int col)
    {
        int [][] new_matrix = new int[row-2][col-2];
        return new_matrix;
    }


发表于 2019-04-15 15:56:47 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> path = new ArrayList<>();
        int rows = 0;

        if (matrix != null) {
            rows = matrix.length;
        }

        int cols;

        if (rows > 0) {
            cols = matrix[0].length;
        } else {
            return null;
        }

        /**思路:x标记行,y标记列
         * 每轮更新一个待遍历矩阵,通过其对角线的两个顶点确认该矩阵,
         * 遍历的条件是待遍历矩阵有至少1个元素eX >= sX || eY >= sY
         * sX,sY记录待遍历的的矩阵左上角,eX,eY记录待遍历的矩阵右下角
         */
        int sX = 0, sY = 0,eX = rows - 1,eY = cols - 1;

        //用来跟踪被遍历元素
        int i;

        while (eX >= sX || eY >= sY) {
            //从左向右遍历
            for (i = sY; i <= eY; ++i) {
                path.add(matrix[sX][i]);
            }
            //如果非单行向下移动一格进行从上往下遍历
            if (eX > sX) {
                for (i = sX + 1; i <= eX; ++i) {
                    path.add(matrix[i][eY]);
                }

                //如果非单行且非单列,向左移动一格进行从右往左遍历
                if (eY > sY) {
                    for (i = eY - 1; i >= sY; --i) {
                        path.add(matrix[eX][i]);
                    }
                    //从下往上遍历的前提是非单行且非单列
                    //如果行间隔至少为1,上移一格进行从下往上遍历
                    if (eX - sX > 1) {
                        for (i = eX - 1; i > sX; --i) {
                            path.add(matrix[i][sY]);
                        }
                    }

                }
            }


            //更新确定待遍历矩阵对角线的坐标
            sX += 1;
            sY += 1;

            eX -= 1;
            eY -= 1;

            //出现待遍历矩阵不符合条件的情况结束循环
            if(eX < sX || eY<sY){
                break;
            }
        }

        return path;
    }
}

发表于 2019-04-13 21:24:44 回复(0)
逐圈输出即可
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
       if(matrix==null)
           return null;
        int r1=0;
        int r2=matrix.length-1;
        int c1=0;
        int c2=matrix[0].length-1;
        ArrayList<Integer> list=new ArrayList<>();
        while(r2>=r1&&c2>=c1){
            if(r1==r2){
                for(int i=c1;i<=c2;i++){
                    list.add(matrix[r1][i]);
                }
            }
            else if(c1==c2){
                for(int i=r1;i<=r2;i++){
                    list.add(matrix[i][c1]);
                }
            }
            else{
                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]);
                }
                for(int i=c2-1;i>=c1;i--){
                    list.add(matrix[r2][i]);
                }
                for(int i=r2-1;i>=r1+1;i--){
                    list.add(matrix[i][c1]);
                }
            }
            r1++;r2--;c1++;c2--;
        }
        return list;
    }
}
发表于 2019-04-13 16:36:43 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int height = matrix.length;
        int width = matrix[0].length;
        if (height == 0 || width == 0) {
            return null;
        }

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

        int top = 0, left = 0, bottom = height - 1, right = width - 1;
        while (top <= bottom && left <= right) {
            //向左
            for (int i = left; i <= right; ++i) {
                result.add(matrix[top][i]);
            }
            top++;
            if(top > bottom) break;

            //向下
            for(int i = top; i <= bottom; ++i) {
                result.add(matrix[i][right]);
            }
            right--;
            if(left > right) break;

            //向左
            for(int i = right; i >= left; --i) {
                result.add(matrix[bottom][i]);
            }
            bottom--;
            if(top > bottom) break;

            //向上
            for (int i = bottom; i >= top; --i) {
                result.add(matrix[i][left]);
            }
            left++;
            if(left > right) break;
        }

        return result;

    }
}

发表于 2019-04-12 22:57:03 回复(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 cols=matrix[0].length; ////矩阵的列数
        int start=0;
        while(rows>start*2&&cols>start*2){
            shundayin(matrix,rows,cols,start);
            start++;
        }
        return list;
    }
    
    
    public void shundayin(int[][] matrix,int rows,int cols,int start){
        
        /////首先从左到右进行遍历
        for(int i=start;i<cols-start;i++){
            list.add(matrix[start][i]);
        }
        
        //////接着从右到下进行遍历
        for(int j=start+1;j<rows-start;j++){
            list.add(matrix[j][cols-start-1]);
        }
        //////接着从下到左进行遍历
        for(int k=cols-start-2;k>=start&&rows-start-1!=start;k--){
            list.add(matrix[rows-start-1][k]);
        }
        //////接着从左到上开始比遍历
        for(int n=rows-start-2;n>start&&cols-start-1!=start;n--){
            list.add(matrix[n][start]);
        }
        
    }
}
发表于 2019-04-09 19:36:50 回复(0)
java 改了好多次才通过,感觉外层循环这样写不是很好

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int xStart = 0,yStart = 0;
        int xEnd = matrix[0].length, yEnd = matrix.length;
        int x,y;
        int numsOfMatrix = matrix.length * matrix[0].length;
        ArrayList<Integer> list = new ArrayList<>();
        
        for(int i = 0; i < numsOfMatrix; ){
            y = yStart;
            for(x = xStart; x < xEnd;x++,i++){
                list.add(matrix[y][x]);
            }
            if(i >= numsOfMatrix){
                break;
            }
            for(x--,y++; y < yEnd; i++,y++){
                list.add(matrix[y][x]);
            }
            if(i >= numsOfMatrix){
                break;
            }
            for(y--,x--; x >= xStart; i++,x--){
                list.add(matrix[y][x]);
            }
            if(i >= numsOfMatrix){
                break;
            }
            for(x++,y--; y > yStart; i++,y--){
                list.add(matrix[y][x]);
            }
            xStart++;
            yStart++;
            xEnd--;
            yEnd--;
        }
        return list;
    }
}

发表于 2019-04-06 16:20:03 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
      ArrayList<Integer> list = new ArrayList<Integer>();
        int r1 = 0;
        int y1 = 0;
        int r2 = matrix.length - 1;
        int y2 = matrix[0].length - 1;
        while (r1 <= r2 && y1 <= y2) {
            if (r1 == r2) {
                for (int i = y1; i <= y2; i++) {
                    list.add(matrix[r1][i]);
                }
            }

            else if (y1 == y2) {
                for (int i = r1; i <= r2; i++) {
                    list.add(matrix[i][y1]);
                }
            } else {

                int curR = r1;
                int curC = y1;
                while (curC < y2) {
                    list.add(matrix[curR][curC]);
                    curC++;
                }
                while (curR < r2) {
                    list.add(matrix[curR][curC]);
                    curR++;
                }
                while (curC > y1) {
                    list.add(matrix[curR][curC]);
                    curC--;
                }
                while (curR > r1) {
                    list.add(matrix[curR][curC]);
                    curR--;
                }
            }
            r1++;
                y1++;
                r2--;
                y2--;
        }
        return list;
    }
}
发表于 2019-04-03 09:46:50 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList <Integer> array = new ArrayList();
        
        //按顺时针打印数字
        //按圈循环, 每一圈作为一个循环体
        //出循环的条件是, 4个基点坐标之间的关系
        //定义4个循环控制变量
        int h1 = 0;    //横坐标1, 初值为0;
        int h2 = matrix.length -1 ;//横坐标2, 初值为二维数组的长度-1
        int z1 = 0;    //纵坐标1, 初值为0;
        int z2 = matrix[0].length-1;    //纵坐标2, 初值为一维数组长度-1
        while(h1<=h2 && z1<=z2)    //循环控制条件
        {
            //循环体内部, 控制添加数据
             //打印最上面一行数据
            for(int j=z1; j<=z2; j++)
            {
                array.add(matrix[h1][j]);
            }
            ////打印最右边一行数据
            for(int i=h1+1; i<=h2; i++)
            {
                array.add(matrix[i][z2]);
            }
              //打印最下面一行数据
            if( z1 != z2  && h1 != h2)        //加控制, 防止重复打印
            {
          
                //打印最下面一行数据
                for(int j=z2-1; j>=z1; j--)
                {
                    array.add(matrix[h2][j]);
                }
                //打印最左边一行数据, 注意边界值
                for(int i=h2-1; i>h1; i--)
                {
                    array.add(matrix[i][z1]);
                }
            }
            //循环变量的变化
            h1++;
            h2--;
            z1++;
            z2--;
            
            
            
        }
      // System.out.print(matrix.length);
        return array;
        
    }
}
发表于 2019-04-02 11:28:15 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        int col_len = matrix[0].length;     // 列数
        int row_len = matrix.length;        // 行数
        int top = 0, left = 0, right = col_len - 1, bottom= row_len - 1;
        int i = 0 ;
        while(true){
            for(i = left; i <= right ; i++)
                result.add(matrix[top][i]);
            if(i == left)
                break;  // 这些break就是用来判断这个for循环有没有运行
                    // 如果没有运行就直接跳出了 因为已经打印完了
            top++;
            for(i = top; i <= bottom; i ++ )
                result.add(matrix[i][right]);
            if(i == top)
                break;
            right--;
            for(i = right ; i >= left ; i--)
                result.add(matrix[bottom][i]);
            if(i == right)
                break;
            bottom--; 
            for(i = bottom; i >= top ; i--)
                result.add(matrix[i][left]);
            if(i == bottom)
                break;
            left++;
        }
        return result;
    }
}

发表于 2019-04-02 10:03:23 回复(0)
对...对不起..我太笨..我选择递归...
思路就是一圈一圈往里面打印..他还有单行单列的..那就在里面排除掉...向右向下运行时肯定是第一次,就不判断,向左向上的时候就做个判断..
import java.util.ArrayList; public class Solution {     public ArrayList<Integer> printMatrix(int [][] matrix) {         ArrayList<Integer> ret = new ArrayList<>();         doPrint(ret,matrix,0,matrix.length-1,matrix[0].length-1);         return ret;     }     public void doPrint(ArrayList<Integer> ret,int[][] matrix,int start,int hight,int width){         if(start>width)return;         if(start>hight)return;         for(int i = start;i<=width;i++){             ret.add(matrix[start][i]);         }         for(int j = start+1;j<=hight;j++){             ret.add(matrix[j][width]);         }         for(int m = width-1;m>=start&&hight>start;m--){             ret.add(matrix[hight][m]);         }         for(int n = hight-1;n>start&&width>start;n--){             ret.add(matrix[n][start]);         }         doPrint(ret,matrix,start+1,hight-1,width-1);     } }

发表于 2019-03-31 21:39:37 回复(0)
搞了半天,终于搞出来了

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        if(matrix==null)return null ;
         ArrayList<Integer> list = new ArrayList<Integer>();
        boolean b = true ;
        int x1 = 0,y1 = 0,x2=matrix.length-1,y2=matrix[0].length-1;
        int size =(x2+1)*(y2+1);
      while(list.size()<size){
                if(b){
                        for(int i=y1;i<=y2; i++){
                           list.add(matrix[x1][i]);
                        }
                    x1++;
                        for(int i=x1;i<=x2; i++){
                            list.add(matrix[i][y2]);
                           
                        }
                     y2--;
                        b=false;
                }else{
                   
                            for(int i=y2;i>=y1; i--){
                               list.add(matrix[x2][i]);
                                
                            }
                  
                   x2--;
                       for(int i=x2;i>=x1; i--){
                                list.add(matrix[i][y1]);   
                            }
                   y1++;
                     b=true;
                       }
    }
    
        return list;
    }
}

发表于 2019-03-31 10:56:04 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        //获得矩阵行数
        int rows = matrix.length;
        //获得矩阵列数
        int columns = matrix[0].length;
        //定义一个列表,用于存放要按要求打印的数据
        ArrayList<Integer> list = new ArrayList<Integer>();
        int start = 0;  //定义第start圈
        //让循环继续的条件:当前矩阵行数大于该圈循环开始的行数的两倍
        //               and 当前矩阵列数大于该圈循环开始的列数的两倍
        //               (每圈循环开始的行数、列数相同)
        while(rows > start*2 && columns > start*2){
            //每一圈最后一行下标
            int endRow = rows - 1 - start;
            //每一圈最后一列下标
            int endColumn = columns - 1 -start;
            /*开始一圈圈打印,每打印一圈分为四步:
                    1.从左到右
                    2.从上到下
                    3.从右到左
                    4.从下到上*/
            //1.从左到右,第一步一定会走,无条件
            for(int i = start;i <= endColumn;i++){
                list.add(matrix[start][i]);
            }
            //2.从上到下,条件:最后一行大于开始行
            if(endRow > start){
                 for(int i = start + 1;i <= endRow;i++){
                    list.add(matrix[i][endColumn]);
                }
            }
            //3.从右到左,条件:最后一行大于开始行,最后一列大于开始列
            if(endRow > start && endColumn > start){
                for(int i = endColumn -1;i >= start;i--){
                    list.add(matrix[endRow][i]);
                }
            }
            //4.从下到上,条件:至少是三行两列,
                           //也就是最后一行大于开始行加2,
                           //最后一列大于开始列
            if(endRow >= start+2 && endColumn > start){
                for(int i = endRow - 1;i > start;i--){
                    list.add(matrix[i][start]);
                }
            }
            //继续打印下一圈
            start++;
        }
        //返回我们需要打印的列表
        return list;
    }
    public static void main(String[] args){
        //自定义一个矩阵
        int[][] matrix =
        {
            
            { 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, 6, 7, 8 },
            { 13, 14, 15, 16 }
            */
        };
        Solution s = new Solution();
        //声明一个数组列表,用于存放返回的要打印的列表值
        ArrayList<Integer> printList = new ArrayList<Integer>();
        printList = s.printMatrix(matrix);
        //循环打印要求的列表中的值
        for (int i = 0; i < printList.size(); i++)
        {
            System.out.print(printList.get(i) + "\0");
        }
    }
}

编辑于 2019-03-28 21:18:38 回复(0)

import java.util.ArrayList;
public class Solution {
    // 挺难的一道题,目前的解法,还存在很大的优化空间,代码应该可以更简练
    public ArrayList printMatrix(int[][] matrix) {
        ArrayList res = new ArrayList();
        int row = matrix.length; // 行
        int col = matrix[0].length; // 列
        if (row == 0 || col == 0) return null;
        // 如果只有一行或者一列,返回这行或这列就行
        if (col == 1) {
            for (int j = 0; j < row; j++) {
                res.add(matrix[j][0]);
            }
            return res;
        }
        if (row == 1) {
            for (int j = 0; j < col; j++) {
                res.add(matrix[0][j]);
            }
            return res;
        }
        int times = Math.min(row, col) / 2; // 一共需要跑几圈,行列取小值除以2
        int i = 0;
        // 以下4个方向的跑法,涉及到的行列,对应matrix[A][B]的AB
        for (; i < times; i++) {
            // 左右
            for (int j = i; j < col - 1 - i; j++) {
                res.add(matrix[i][j]);
            }
            // 上下
            for (int j = i; j < row - 1 - i; j++) {
                res.add(matrix[j][col - 1 - i]);
            }
            // 右左
            for (int j = col - 1 - i; j > i; j--) {
                res.add(matrix[row - 1 - i][j]);
            }
            // 下上
            for (int j = row - 1 - i; j > i; j--) {
                res.add(matrix[j][i]);
            }
        }
        // 如果行列取小值是奇数,那么漏掉中心一行/列
        if ((Math.min(row, col) & 1) == 1) {
            if (row == Math.min(row, col)) {
                for (int j = times; times < col - i; times++) {
                    res.add(matrix[row - 1 - i][times]);
                }
            } else {
                for (int j = times; times < row - i; times++) {
                    res.add(matrix[times][col - 1 - i]);
                }
            }
        }
        return res;
    }
}
编辑于 2019-03-28 14:39:22 回复(0)
//顺时针遍历矩阵规律如下,先列增,再行增,再列减,再行减,只要确定边界就可以完成遍历了
 //int[][] operate = {{0,1}
         //                 ,{1,0}
            //              ,{0,-1},
                //          {-1,0}};

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        if(matrix==null||matrix[0]==null) return null;
        
        ArrayList<Integer> result = new ArrayList<Integer>();
        
       //int[][] operate = {{0,1}
         //                 ,{1,0}
            //              ,{0,-1},
                //          {-1,0}};
        int minI = 0, maxI = matrix.length-1 ,
        minJ = 0, maxJ = matrix[0].length-1;
        
        int operateIndex = 0,i=0,j=0;
        while(minI<=maxI&&minJ<=maxJ){
            result.add(matrix[i][j]);
            switch(operateIndex){
                case 0: {
                    if(j==maxJ){
                        minI++;
                        i++;
                        operateIndex = (operateIndex+1)%4;
                    }else{
                        j++;
                    }
                    break;
                }
                case 1: {
                    if(i==maxI){
                        maxJ--;
                        j--;
                        operateIndex = (operateIndex+1)%4;
                    }else{
                        i++;
                    }
                    break;
                }
                case 2: {
                    if(j==minJ){
                        maxI--;
                        i--;
                        operateIndex = (operateIndex+1)%4;
                      
                    }else{
                        j--;
                    }
                    break;
                }
                case 3: {
                    if(i==minI){
                        minJ++;
                        j++;
                        operateIndex = (operateIndex+1)%4;
                       
                    }else{
                        i--;
                    }
                }
            }
        }
        return result;
        
    }
}
发表于 2019-03-28 09:20:58 回复(0)
 
public ArrayList<Integer> printMatrix(int [][] matrix) { if(null == matrix) return null;  int map[][] = new int[matrix.length][matrix[0].length];  return loop(0,0,map,matrix); } /**  *  * @param x  * @param y  * @param map  * @param matrix  * @return  */ public ArrayList<Integer> loop(int x,int y,int map[][],int [][] matrix){
    ArrayList<Integer> list = new ArrayList<>();   final int sum = matrix.length * matrix[0].length;  int count = 0;  while (true){ if(sum == count){ break;  } while(y>= 0&& y <map[0].length && map[x][y] == 0){
            list.add(matrix[x][y]);  map[x][y] = 1;  y++;  count++;  } //y轴出界,修正  y--;  //当前x轴已经覆盖,修正  x++;  while(x>= 0&& x <map.length && map[x][y] == 0 ){
            list.add(matrix[x][y]);  map[x][y] = 1;  x++;  count++;  } //x轴出界,修正  x--;  //当前y轴已经覆盖,修正  y--;  while(y>= 0&& y <map[0].length && map[x][y] == 0){
            list.add(matrix[x][y]);  map[x][y] = 1;  y--;  count++;  } //y轴出界,修正  y++;  //当前x轴已经覆盖,修正  x--;  while(x>= 0&& x <map.length && map[x][y] == 0){
            list.add(matrix[x][y]);  map[x][y] = 1;  x--;  count++;  } //x轴出界,修正  x++;  //y轴已经覆盖过,修正  y++;  } return list; }

发表于 2019-03-25 10:55:16 回复(0)

遇到撞墙或者访问过的就顺时针转90度

import java.util.ArrayList;
public class Solution {
    public static ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> ret = new ArrayList<>();
        int n = matrix.length;
        if (n == 0) return ret;
        int m = matrix[0].length;

        boolean[][] isReach = new boolean[n][m];
        int [] dx = {0, 1, 0, -1}, dy = {1, 0, -1, 0};
        int x = 0, y = 0, d = 0;
        for (int i = 0; i < m*n; i++) {
            ret.add(matrix[x][y]);
            isReach[x][y] = true;
            int a = x + dx[d], b = y + dy[d];
            if (a < 0 || b < 0 || a >= n || b >= m || isReach[a][b] == true){
                d = (d + 1) % 4;
                a = x + dx[d];
                b = y + dy[d];
            }
            x = a;
            y = b;
        }
        return ret;
    }
}
编辑于 2019-03-24 11:51:22 回复(0)
public static ArrayList<Integer> printMatrix(int [][] matrix) { int sum = matrix.length * matrix[0].length;  ArrayList<Integer> list = new ArrayList<>(sum);  int left = 0;  int right = matrix[0].length - 1;  int top = 0;  int bottom = matrix.length - 1;  int i = 0, j = 0;  // 定义此时的方向,0代表向右,1 = 下,2 = 左, 3 = 上。  int status = 0;  while (list.size() < sum ) { if (status == 0) { // System.out.println("i = " + i + ", j = " + j);  while (j <= right) {
                list.add(matrix[i][j]);  //   System.out.println(matrix[i][j]);  j++;  }
            status = 1;  top++;  i = top;  j = right;  } else if (status == 1) { while (i <= bottom) {
                list.add(matrix[i][j]);  //   System.out.println(matrix[i][j]);  i++;  }
            status = 2;  right--;  j = right;  i = bottom;   } else if (status == 2) { while (j >= left) {
                list.add(matrix[i][j]);  //   System.out.println(matrix[i][j]);  j--;  }
            status = 3;  bottom--;  j = left;  i = bottom;  } else if (status == 3) { while (i >= top) {
                list.add(matrix[i][j]);  //   System.out.println(matrix[i][j]);  i--;  }
            status = 0;  left ++;  i = top;  j = left;  }
    } return list; }
发表于 2019-03-24 10:28:32 回复(0)
import java.util.ArrayList;
public class Solution {
    private static class Point {
        int x;
        int y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
      //想法很朴素,就是走一个回字,由4个顶点的坐标决定。每走一圈,4个顶点都向
      //内45度向移动一个位置。
      //重点在何时结束遍历:当左下角的点与左上角的点位置发生上下交换时
      //或者左下角的点与右下角的点的位置发生左右交换时,都说明已经遍历完了,结束
      //为方便处理边界点的位置,利用了一个数组进行标记某个元素是否已经遍历过了,如果遍历过了就结束
       //时间复杂为O(N)
    public ArrayList<Integer> printMatrix(int[][] matrix) {
        int vertial = matrix.length;
        int horizontal = matrix[0].length;
        Point upperLeft = new Point(0, 0);
        Point upperRight = new Point(0, horizontal - 1);
        Point lowerLeft = new Point(vertial - 1, 0);
        Point lowerRight = new Point(vertial - 1, horizontal - 1);
        //update Boundry
        boolean[][] visited = new boolean[vertial][horizontal];
        ArrayList<Integer> result = new ArrayList<>();
        while (upperLeft.x <= lowerLeft.x && upperLeft.y <= upperRight.y) {
            for (int x = upperLeft.x, y = upperLeft.y; y <= upperRight.y; ++y) {
                if (!visited[x][y]) {
                    visited[x][y] = true;
                    result.add(matrix[x][y]);
                }
            }
            for (int x = upperRight.x, y = upperRight.y; x <= lowerRight.x; ++x) {
                if (!visited[x][y]) {
                    visited[x][y] = true;
                    result.add(matrix[x][y]);
                }
            }
            for (int x = lowerRight.x, y = lowerRight.y; y >= lowerLeft.y; --y) {
                if (!visited[x][y]) {
                    visited[x][y] = true;
                    result.add(matrix[x][y]);
                }
            }
            for (int x = lowerLeft.x, y = lowerLeft.y; x >= upperLeft.x; --x) {
                if (!visited[x][y]) {
                    visited[x][y] = true;
                    result.add(matrix[x][y]);
                }
            }
            ++upperLeft.x;
            ++upperLeft.y;
            ++upperRight.x;
            --upperRight.y;
            --lowerLeft.x;
            ++lowerLeft.y;
            --lowerRight.x;
            --lowerRight.y;
        }
        return result;
    }
    public static void main(String[] args) {
        new Solution().printMatrix(new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}});
    }
}

编辑于 2019-03-23 20:00:00 回复(0)
import java.util.*;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> array=new ArrayList<Integer>();
        if(matrix.length==0||matrix[0].length==0)  return array;
        boolean [][] flag=new boolean[matrix.length][matrix[0].length];
        return Path(0,0,matrix,flag,array);
    }
    public ArrayList<Integer> Path(int i,int j,int [][] matrix,boolean [][] flag,ArrayList<Integer> array){
        array.add(matrix[i][j]);
        flag[i][j]=true;
        int tmp=0;//设定优先级,按优先级由小到大的方式写路径。
        if(i>=1&&flag[i-1][j]==false)  tmp=1;
        if(j>=1&&flag[i][j-1]==false)  tmp=2;
        if(i<matrix.length-1&&flag[i+1][j]==false) tmp=3;
        if(j<matrix[0].length-1&&flag[i][j+1]==false) tmp=4;
        if(tmp==0) return array;
        else if(tmp==1) return Path(i-1,j,matrix,flag,array);
        else if(tmp==2) return Path(i,j-1,matrix,flag,array);
        else if(tmp==3) return Path(i+1,j,matrix,flag,array);
        else{
            if(i>=1&&flag[i-1][j]==false){
                return Path(i-1,j,matrix,flag,array);
            }
            else
                return Path(i,j+1,matrix,flag,array);
        }
    }
}

发表于 2019-03-22 15:46:17 回复(0)

扫一扫,把题目装进口袋

牛客网,程序员必备求职神器

扫描二维码,进入QQ群

扫描二维码,关注牛客网公众号