Leetcode 498.对角线遍历

对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。

   

示例:

输入:

[

[ 1, 2, 3 ],

[ 4, 5, 6 ],

[ 7, 8, 9 ]

]

输出: [1,2,4,7,5,3,6,8,9]

解释:

   

说明:

1. 给定矩阵中的元素总数不会超过 100000 。

    1 class Solution {
    2     public static int[] findDiagonalOrder(int[][] matrix) {
    3         if (matrix.length == 0 || matrix[0].length == 0) {
    4             return new int[0];
    5         }
    6         int m = matrix.length;
    7         int n = matrix[0].length;
    8         int[] order = new int[m * n];
    9         int row = 0;
   10         int col = 0;
   11         //存储方向改变值，右上，或者左下
   12         int[][] dirs = {{-1, 1}, {1, -1}};
   13         int k = 0;
   14         for (int i = 0; i < order.length; i++) {
   15             //将当前坐标赋值给新数组
   16             order[i] = matrix[row][col];
   17             //计算下一个点的坐标
   18             row += dirs[k][0];
   19             col += dirs[k][1];
   20             //根据边界条件，修正下一个点的坐标值.触碰边界，必然对方向取反
   21             // 右上方向碰到边界
   22             if (col > n - 1) {
   23                 col = n - 1;
   24                 row += 2;
   25                 //方向取反
   26                 k = 1 - k;
   27             }
   28             if (row < 0) {
   29                 row = 0;
   30                 k = 1 - k;
   31             }
   32             //左下方向碰到边界
   33             if (row > m - 1) {
   34                 row = m - 1;
   35                 col += 2;
   36                 k = 1 - k;
   37             }
   38             if (col < 0) {
   39                 col = 0;
   40                 k = 1 - k;
   41             }
   42         }
   43         return order;
   44     }
   45 }

class Solution {
public static int[] findDiagonalOrder(int[][] matrix) {
if (matrix.length == 0 || matrix[0].length == 0) {
return new int[0];
}
int m = matrix.length;
int n = matrix[0].length;
int[] order = new int[m * n];
int row = 0;
int col = 0;
//存储方向改变值，右上，或者左下
int[][] dirs = {{-1, 1}, {1, -1}};
int k = 0;
for (int i = 0; i < order.length; i++) {
//将当前坐标赋值给新数组
order[i] = matrix[row][col];
//计算下一个点的坐标
row += dirs[k][0];
col += dirs[k][1];
//根据边界条件，修正下一个点的坐标值.触碰边界，必然对方向取反
// 右上方向碰到边界
if (col > n - 1) {
col = n - 1;
row += 2;
//方向取反
k = 1 - k;
}
if (row < 0) {
row = 0;
k = 1 - k;
}
//左下方向碰到边界
if (row > m - 1) {
row = m - 1;
col += 2;
k = 1 - k;
}
if (col < 0) {
col = 0;
k = 1 - k;
}
}
return order;
}
}