Java沿对角线遍历矩阵的几种方式

1. 左下方-右上方遍历
   

    public static int[] findOrder(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++){
            for(int j = Math.min(i, m-1); j >= Math.max(0, i-n+1); j--){
                result[index++] = mat[j][i-j];
            }
        }
        return result;
    }

矩阵的对角线总数为m+n-1，所以需要m+n-1次遍历，1 <= i <= m+n-1
第i次遍历的元素个数为m+n-2-i，
其中m是行数，n是列数。

边界条件的确定：
假设start是起始索引，end是结束索引，
恒成立: m-1 >= start >= end >= 0

进一步确定start和end的范围。因为总是从最左下方开始遍历，所以当i <= m - 1时，start = i，当 i > m - 1时，i = m - 1，所以start = min(i, m-1)

同理，因为总是从最右上方结束，观察到当 i <= m - 1时，end = 0，当i > m - 1时，end > 0， 此时end的值可以由[起始索引]-[该次遍历的元素个数]得出，即end = m - 1 - (m + n - 2 - i) = i - n + 1，所以end = max(0, i -n+1)

由于元素沿对角线对称，所以遍历的元素总是mat[j][i-j]。

2. 右上方-左下方遍历
   

    public static int[] findOrder(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++){
            for(int j = Math.max(0, i-n+1); j <= Math.min(i, m-1); j++){
                result[index++] = mat[j][i-j];
            }
        }
        return result;
    }

同理上一种情况，当然也可以通过先沿对角线翻转元素再用左下方-右上方的方法实现。

3. 左下方-右上方交替遍历
   

    public static int[] findOrder(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){
                for(int j = Math.min(i, m-1); j >= Math.max(0, i-n+1); j--){
                    result[index++] = mat[j][i-j];
                }
            }

            else{
                for(int j = Math.max(0, i-n+1); j <= Math.min(i, m-1); j++){
                    result[index++] = mat[j][i-j];
                }
            }
        }
        return result;
    }

对于交替遍历的问题，只需将遍历次数分为奇偶数进行讨论即可。也可以将特定对角线上的元素沿对角线翻转后再用同一种方法。

        for(int i = 0; i < m; i++){
            if(i % 2 != 0){
            //沿左上-右下对角线翻转
                for (int j = 0; j < i; j++){
                    int temp = mat[i][j];
                    mat[i][j] = mat[j][i];
                    mat[j][i] = temp;
                }
            }
        }

        for(int i =0; i < m+n-1; i++){
            for(int j = Math.min(i, m-1); j >= Math.max(0, i-n+1); j--){
                result[index++] = mat[j][i-j];
            }
        }
        return result;

对于其他遍历方式，比如说从左上方-右下方，可以先通过将原二维数组元素垂直翻转（沿水平轴），再使用同样的方法即可实现。注意此时的遍历起点是左下角，如果需要从右上角开始遍历，可以在垂直翻转后再沿右上-左下为对称轴翻转数组元素（实际上相当于直接将原数组逆时针旋转90°）。

逆时针旋转90°：先左上-右下对角线翻转，再水平翻转
顺时针旋转90°：先水平翻转，再左上-右下对角线翻转

但是这种翻转数组的方法缺点是会破会原始数据，需要new一个新的二维数组进行赋值。