leetCode-498: 对角线遍历

题目描述

给你一个大小为 m x n 的矩阵 mat ，请以对角线遍历的顺序，用一个数组返回这个矩阵中的所有元素。

示例

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：mat = [[1,2],[3,4]]
输出：[1,2,3,4]

解题过程

思路及步骤

（1）m * n 的二维矩阵, 总共有 m + n - 1 条对角线, 相邻的对角线的遍历方向不同；
（2）设对角线从上到下的编号为 [0,m + n − 2]。当 i 为偶数时, 遍历方向为从左下向右上遍历;当 i 为奇数时，遍历方向为从右上向左下遍历;
（3）当第 i 条对角线为从左下向右上遍历时, 即 i 为偶数时, 每次行索引减 1, 列索引加 1, 直到矩阵的边缘为止;
      当 i < m 时, 此时对角线遍历的起点位置为 (i, 0);
      当 i ≥ m 时，此时对角线遍历的起点位置为 (m − 1, i − m + 1);
（4）当第 i 条对角线为从右上向左下遍历时, 即 i 为奇数时, 每次行索引加 1, 列索引减 1, 直到矩阵的边缘为止;
      当 i < n 时, 此时对角线遍历的起点位置为 (0, i);
      当 i ≥ n 时，则此时对角线遍历的起点位置为 (i − n + 1, n − 1);

代码展示

public class FindDiagonalOrder {

    /**
     * 官方解答：
     * m * n 的二维矩阵, 总共有 m + n - 1 条对角线, 相邻的对角线的遍历方向不同
     * 设对角线从上到下的编号为 [0,m + n − 2]
     * 当 i 为偶数时, 遍历方向为从左下向右上遍历;
     * 当 i 为奇数时，遍历方向为从右上向左下遍历;
     *
     * 当第 i 条对角线为从左下向右上遍历时, 即 i 为偶数时, 每次行索引减 1, 列索引加 1, 直到矩阵的边缘为止;
     *   当 i < m 时, 此时对角线遍历的起点位置为 (i, 0);
     *   当 i ≥ m 时，此时对角线遍历的起点位置为 (m − 1, i − m + 1);
     *
     * 当第 i 条对角线为从右上向左下遍历时, 即 i 为奇数时, 每次行索引加 1, 列索引减 1, 直到矩阵的边缘为止;
     *   当 i < n 时, 此时对角线遍历的起点位置为 (0, i);
     *   当 i ≥ n 时，则此时对角线遍历的起点位置为 (i − n + 1, n − 1);
     **/

    public int[] findDiagonalOrder(int[][] mat) {
        // 行
        int m = mat.length;
        // 列
        int n = mat[0].length;
        int[] result = new int[m * n];
        int index = 0;
        for (int i = 0; i < m + n - 1; i++) {
            if (i % 2 == 0) {
                // 第偶数条对角线
                int row = 0;
                int line = 0;
                if (i < m) {
                    row = i;
                }
                if (i >= m) {
                    row = m - 1;
                    line = i - m + 1;
                }
                while (row >= 0 && line < n) {
                    result[index] = mat[row][line];
                    row--;
                    line++;
                    index++;
                }
            } else {
                // 第奇数条对角线
                int row = 0;
                int line = 0;
                if (i < n) {
                    line = i;
                }
                if (i >= n) {
                    row = i - n + 1;
                    line = n - 1;
                }
                while (row < m && line >= 0) {
                    result[index] = mat[row][line];
                    row++;
                    line--;
                    index++;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] mat = {{1,2,3},
                       {4,5,6},
                       {7,8,9}};
        int[] result = new FindDiagonalOrder().findDiagonalOrder(mat);
        for (int i = 0; i < result.length; i++) {
            System.out.printf("%2d", result[i]);
        }
        System.out.println();
    }

}