数据结构-对角线遍历(C#实现)

1.问题:

给定一个大小为 m x n 的矩阵 mat ,以对角线遍历的顺序,用一个数组返回这个矩阵中的所有元素,如下图所示:

2.思路:

根据题目,在第一次遍历时,可以发现,其坐标为(0,0),而往上遍历下一个时,坐标变为(-1,1),此时此坐标在矩阵中并不存在,因此开始第二个对角线的遍历,此时需要遍历的坐标变为(0,1),其下一个遍历的坐标为(1,0),而继续遍历时,遍历坐标为(2,-1),此时第二条对角线遍历结束,接下去的对角线遍历都可以此类推,至此,可以发现,第一条对角线,也即奇数次对角线遍历的坐标变化规律为行数-1,而列数+1,而偶数次对角线的变化规律为行数+1,列数-1

由此,便只需使用while循环,同时控制好边界跳出条件即可实现遍历。

3.C#实现:
public static int[] FindDiagonalOrder(int[][] mat)
    {
        int colLenth= mat[0].Length;
        int rowLenth= mat.Length;
        List<int> result = new();
        int number = 0;// 对角线遍历次数
        int col = 0;// 最近一次遍历到的列数
        int row = 0;// 最近一次遍历到的行数
        int total = colLenth + rowLenth - 1;// 总对角线数
        while (number < total)
        {
            number++;
            if (number%2==0)//偶数次遍历
            {
                while (row< rowLenth)
                {
                    result.Add(mat[row][col]);
                    row++;
                    if (row >= rowLenth)
                    {
                        break;
                    }
                    col--;
                    if (col < 0)
                    {
                        col = 0;
                        break;
                    }

                }
                if (row >= rowLenth)
                {
                    row = rowLenth - 1;
                    col++;
                }

            }
            else// 奇数次遍历
            {
                while (col < colLenth)
                {
                    result.Add(mat[row][col]);
                    col++;
                    if (col >= colLenth)
                    {
                        break;
                    }
                    row--;
                    if (row<0)
                    {
                        row = 0;
                        break;
                    }
                }
                if (col >= colLenth)
                {
                    col = colLenth - 1;
                    row++;
                }

            }
        }
        return result.ToArray();
    }

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java实现方阵的对角线遍历可以使用两个指针来实现。具体实现步骤如下: 1. 首先定义两个指针,一个指向左上角,一个指向右下角。 2. 然后分别移动这两个指针,从左上角开始,每次遍历对角线上的元素后,再移动到下一条对角线上的起始位置,直到遍历完整个方阵。 3. 在每次遍历时,可以使用一个ArrayList来存储对角线上的元素,遍历完后将ArrayList加入到一个二维数组中。 以下是Java实现方阵对角线遍历的代码示例: ```java public static int[][] diagonalTraversal(int[][] matrix) { int m = matrix.length; int n = matrix.length; int[][] result = new int[m][n]; int index = 0; ArrayList<Integer> temp = new ArrayList<>(); // 从左上角开始 int i = 0, j = 0; while (i < m && j < n) { temp.clear(); // 遍历当前对角线 while (i >= 0 && j < n) { temp.add(matrix[i][j]); i--; j++; } // 将对角线元素加入结果数组 for (int k = temp.size() - 1; k >= 0; k--) { result[index][k] = temp.get(k); } index++; // 移动指针到下一条对角线起始位置 if (i < 0 && j <= n - 1) { i = 0; } else { i++; } j = Math.max(j, 0); } // 从右上角开始 i = 0; j = n - 1; while (i < m && j >= 0) { temp.clear(); // 遍历当前对角线 while (i < m && j >= 0) { temp.add(matrix[i][j]); i++; j--; } // 将对角线元素加入结果数组 for (int k = temp.size() - 1; k >= 0; k--) { result[index][n - k - 1] = temp.get(k); } index++; // 移动指针到下一条对角线起始位置 if (j < 0 && i <= m - 1) { j = 0; } else { j--; } i = Math.max(i, 0); } return result; } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值