力扣 498. 对角线遍历

题目

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

示例

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

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

解释:

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/diagonal-traverse
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法1

class Solution:
    
    def findDiagonalOrder(self, matrix: List[List[int]]) -> List[int]:
        
        # Check for empty matrices
        if not matrix or not matrix[0]:
            return []
            
        N, M = len(matrix), len(matrix[0])
        result, intermediate = [], []
        
        for d in range(N + M - 1):
            intermediate.clear()
            r, c = 0 if d < M else d - M + 1, d if d < M else M - 1
            while r < N and c > -1:
                intermediate.append(matrix[r][c])
                r += 1
                c -= 1
            if d % 2 == 0:
                result.extend(intermediate[::-1])
            else:
                result.extend(intermediate)
        return result        

作者：LeetCode
链接：https://leetcode-cn.com/problems/diagonal-traverse/solution/dui-jiao-xian-bian-li-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Python实现

class Solution:
    def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
        row=len(mat)
        col=len(mat[0])
        k=0
        out,var=list(),list()
        for k in range(col+row-1):
            var.clear()
            for i in range(row):
                if i<=k and k-i<col:
                    var.append(mat[i][k-i])
            if k%2!=0:
                out.extend(var)
            else:
                out.extend(var[::-1])
        return out

extend()函数

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

列表 [::-1] 的使用
返回整个的倒序：如abcde
–>edcba

Python实现

class Solution:
    def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
        row=len(mat)
        col=len(mat[0])
        k=0
        out=list()
        for k in range(col+row-1):
            if k%2 != 0: #奇数和k=0
                for i in range(row):
                    if i<=k and k-i<col:
                        out.append(mat[i][k-i])
            if k%2==0: #偶数
                for i in range(row-1,-1,-1):
                    if i<=k and k-i<col:
                        out.append(mat[i][k-i])
        return out

Java实现1

class Solution {
    public int[] findDiagonalOrder(int[][] mat) {
        if (mat == null || mat.length == 0) {
            return new int[]{};
        }
        int m = 0, n = 0;
        int row = mat.length, col = mat[0].length;
        int[] res = new int[row * col];
        for (int i = 0; i < res.length; i++) {
            res[i] = mat[m][n];
            // m + n 即为遍历的层数，偶数向上遍历，奇数向下遍历
            if ((m + n) % 2 == 0) {
                if (n == col - 1) {
                    // 往下移动一格准备向下遍历
                    m++;
                } else if (m == 0) {
                    // 往右移动一格准备向下遍历
                    n++;
                } else {
                    // 往上移动
                    m--;
                    n++;
                }
            } else {
                if (m == row - 1) {
                    // 往右移动一格准备向上遍历
                    n++;
                } else if (n == 0) {
                    // 往下移动一格准备向上遍历
                    m++;
                } else {
                    // 往下移动
                    m++;
                    n--;
                }
            }
        }
        return res;
    }
}

Java实现2

class Solution {
    public int[] findDiagonalOrder(int[][] mat) {
        int m = mat.length, n = mat[0].length;
        int[] res = new int[m * n];
        int idx = 0;

        for (int i = 0; i < m + n - 1; i++) {
            if (i % 2 == 0) {
                int x = i >= m ? m - 1 : i;
                int y = i >= m ? i - m + 1 : 0;
                while (x >= 0 && y < n) {
                    res[idx++] = mat[x--][y++];
                }
            } else {
                int x = i >= n ? i - n + 1 : 0;
                int y = i >= n ? n - 1 : i;
                while (x < m && y >= 0) {
                    res[idx++] = mat[x++][y--];
                }
            }
        }
        return res;
    }
}