遍历二维矩阵的各种花样

已于 2023-11-17 14:40:43 修改
阅读量365 收藏
点赞数 11
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
于 2023-11-16 16:49:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51456741/article/details/134445423
版权

遍历二维矩阵的各种花样

PS：干货很多，建议分多次食用

常规遍历

# 输出以下序列: [1 2 3 4...15 16]

在这里插入图片描述

这个就是按行遍历即可

示例代码

int len = matrix.length;
for (int i = 0; i < len; i++) {
    for (int j = 0; j < len; j++) {
        System.out.print(matrix[i][j]+" ");
    }
}

旋转遍历

PS：本遍历方法使用生成以下矩阵来讲述，生成会了，遍历自然也会了

示意图

在这里插入图片描述

遍历思路

# [0,0] [0,1] [0,2] [0,3]	👉向右
# [0,4] [1,4] [2,4] [3,4]	👇向下
# [4,4] [4,3] [4,2] [4,1]	👆向上
# [4,0] [3,0] [2,0]	[1,0]	👈向左
# ......
圈圈法

第一个思路就是一圈一圈的遍历

将每一个圈拆为四个部分

在这里插入图片描述

第一个循环用来生成水平向左的数据

第二个循环用来生成垂直向下的数据

第三个循环用来生成水平向右的数据

第四个循环用来生成垂直向上的数据

流程图

粉红色的是标注为每次大循环的开始处

PS：图片很多，过程很详细

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

示例代码
public int[][] rotateNumber(int n) {
    int[][] matrix = new int[n][n];
    int counter = 1;
    // n / 2即这个矩阵有几个圈
    for (int i = 0; i < n / 2; i++) {
        // end即本次这个圈的宽-1
        int end = n - i - 1;
        // →
        for (int j = i; j < end; j++) {
            matrix[i][j] = counter++;
        }
        // ↓
        for (int j = i; j < end; j++) {
            matrix[j][end] = counter++;
        }
        // ←
        for (int j = end; j > i; j--) {
            matrix[end][j] = counter++;
        }
        // ↑
        for (int j = end; j > i; j--) {
            matrix[j][i] = counter++;
        }
    }
    // 如果是奇数，单独处理中间那一格数据
    if (n % 2 != 0) {
        matrix[n / 2][n / 2] = n * n;
    }
    return matrix;
}
横平竖直法（推荐）

这种方法是通过四个边界来辅助生成矩阵

四个边界的示意图

在这里插入图片描述

示例代码
public int[][] rotateNumber(int n){
    // 用来存放生成的旋转数字矩阵
    int[][] matrix = new int[n][n];
    // 计数器
    int counter = 1;
    // 上边界
    int up = 0;
    // 下边界
    int down = n-1;
    // 左边界
    int left = 0;
    // 右边界
    int right = n-1;
    // 当 counter 比 n * n 小就一直循环
    while (counter <= n * n) {
        // 遍历上边界的那一行
        for (int j = left; j <= right; j++) {
            matrix[up][j] = counter++;
        }
        // 上边界向下移动一行
        up++;
        // 遍历右边界的那一行
        for (int i = up; i <= down; i++) {
            matrix[i][right] = counter++;
        }
        // 右边界向左移动一行
        right--;
        // 遍历下边界的那一行
        for (int j = right; j >= left; j--) {
            matrix[down][j] = counter++;
        }
        // 下边界向上移动一行
        down--;
        // 遍历左边界的那一行
        for (int i = down; i >= up; i--) {
            matrix[i][left] = counter++;
        }
        // 左边界向右移动那一行
        left++;
    }
    // 返回结果数组
    return matrix;
}

斜遍历

# 输出所有由左上向右下方向的对角线: [13 9 14 5 10 15 1 6 11 16 2 7 12 3 8 4]

在这里插入图片描述

偏移X法

和往常一样遍历第一行，[0,0] [0,1] [0,2] [0,3] [0,4]

可以发现中间那个对角线是这一行向下偏移的结果，但是不同的位置在 X 方向上的偏移量是不一样的

在这里插入图片描述

遍历第二行[1,0] [1,1] [1,2] [1,3] [1,4]

可以看到和刚刚第一行一样，每一列向下偏移一定量就可以得到主对角线下面的那个对角线了

（这里先不要管越界的问题，先把思路理清楚，再在代码里面解决越界问题）

在这里插入图片描述

先写出遍历每一行的初始代码，然后我们在这个上面改造

for (int i = 0; i < len; i++) {
    for (int j = 0; j < len; j++) {
        System.out.println(matrix[i][j]);
    }
}

在遍历每一行的情况，向下偏移就是对角线了

每一列的偏移量都是不一样的，接下来要解决的就是如何算出每一列的偏移量

经过观察可以发现，当前这一列的偏移量就是当前的列值，那么就好办了直接用j就可以了

for (int i = 0; i < len; i++) {
    for (int j = 0; j < len; j++) {
        System.out.println(matrix[i + j][j]);
    }
}

现在还有一个问题，就是得到的对角线是部分不合法的，那么接下来就是如何截取合法的对角线部分

因为对角线是由每一行向下偏移而来，对角线越界的根本原因是每一行遍历多了

那么只要逐渐减少每一行的遍历长度即可，每一行少遍历 i 的长度即可

for (int i = 0; i < len; i++) {
    for (int j = 0; j < len - i; j++) {
        System.out.println(matrix[i + j][j]);
    }
}
完整示例代码

PS：注意右上角

for (int i = len - 1; i >= 0; i--) {
    for (int j = 0; j < len - i; j++) {
        System.out.println(matrix[i + j][j]);
    }
}
for (int i = len - 2; i >= 0; i--) {
    for (int j = len - 1 - i; j < len; j++) {
        // 偏移量
        int offset = len - 1 - j;
        System.out.println(matrix[i - offset][j]);
    }
}
偏移Y法

这个方法和偏移 X 法有异曲同工之妙

只不过从遍历每一行变成了遍历每一列

在这里插入图片描述

和刚刚一样，先写出遍历每一列

for (int j = 0; j < len; j++) {
    for (int i = 0; i < len; i++) {
        System.out.println(matrix[i][j]);
    }
}

然后向右边偏移

for (int j = 0; j < len; j++) {
    for (int i = 0; i < len; i++) {
        System.out.println(matrix[i][j + i]);
    }
}

对角线不合法，截取合法部分

for (int j = 0; j < len; j++) {
    for (int i = 0; i < len - j; i++) {
        System.out.println(matrix[i][j + i]);
    }
}
完整示例代码

PS：注意左下角

for (int j = 0; j < len; j++) {
    for (int i = len - 1 - j; i < len; i++) {
        int offset = len - 1 - i;
        System.out.println(matrix[i][j - offset]);
    }
}
for (int j = 1; j < len; j++) {
    for (int i = 0; i < len - j; i++) {
        System.out.println(matrix[i][i + j]);
    }
}
偏移对角线法（推荐）

可以发现偏移 X 法和偏移 Y 法都比较麻烦

所以我比较推荐这种方法，根据对角线来做偏移就会简单很多

从左上顶角到右下顶角的那条对角线如下[0,0] [1,1] [2,2] [3,3]

@表示越界舍弃

整体往下偏移 1 位，就是[1,0] [2,1] [3,2] [4,3](@)

整体往下偏移 2 位，就是[2,0] [3,1] [4,2](@) [5,3](@)

整体往下偏移 3 位，就是[3,0] [4,1] [5,2](@) [6,3](@)

整体往上偏移 1 位，就是[-1,0](@) [0,1] [1,2] [2,3]

整体往上偏移 2 位，就是[-2,0](@) [-1,1](@) [-1,0][0,2] [1,3]

整体往上偏移 3 位，就是[-3,0](@) [-2,1](@) [-1,2](@) [0,3]

如何解决越界

既然完整的对角线偏移会出现越界，那就偏移部分的对角线不就行了

int len = matrix.length;
// 输出部分对角线，从完整开始逐渐变短
for (int offset = 0; offset < len; offset++) {
    for (int i = 0; i < len - offset; i++) {
        System.out.println(matrix[i][i]);
    }
}
// 这时候输出的依次是
// [0,0] [1,1] [2,2] [3,3]	(offset=0)
// [0,0] [1,1] [2,2]		(offset=1)
// [0,0] [1,1]				(offset=2)
// [0,0]					(offset=3)
// 那么只需要根据部分的对角线向下偏移即可
for (int offset = 0; offset < len; offset++) {
    for (int i = 0; i < len - offset; i++) {
        System.out.println(matrix[i + offset][i]);
    }
}
// 这样的输出结果就是
// [0,0] [1,1] [2,2] [3,3]	(offset=0)
// [1,0] [2,1] [3,2]		(offset=1)
// [2,0] [3,1]				(offset=2)
// [3,0]					(offset=3)

在理解了上述的方法后，修改下来完成第一部分的遍历，即这一块的遍历

在这里插入图片描述

这个和刚刚不同的地方在于它的偏移量是从大到小的，上面那个理解了，这个应该也不难

// [3,0]
// [2,0] [3,1]
// [1,0] [2,1] [3,2]
// [0,0] [1,1] [2,2] [3,3]
// offset是对角线在x方向的偏移量
for (int offset = len - 1; offset >= 0; offset--) {
    for (int i = 0; i < len - offset; i++) {
        // 向下偏移
        System.out.println(matrix[i + offset][i]);
    }
}
完整示例代码
public void tiltPrint(int[][] matrix){
    int len = matrix.length;
    for (int offset = len - 1; offset >= 0; offset--) {
        for (int i = 0; i < len - offset; i++) {
            // 向下偏移
            System.out.println(matrix[i + offset][i]);
        }
    }
    for (int offset = 1; offset < len; offset++) {
        for (int i = offset; i < len; i++) {
            // 向上偏移
            System.out.println(matrix[i - offset][i]);
        }
    }
}

螺旋遍历

# 输出螺旋遍历顺序: [1 2 3 4 5 6 7 8 9 10 11 ... 21]

在这里插入图片描述

拆解法

将这个路径拆解开

拆解如下

# [0,0] -- [0,1] [1,0]
# [2,0] [1,1] [0,2] --- [0,3] [1,2] [2,1] [3,0]
# [4,0] [3,1] [2,2] [1,3] [0,4] --- [0,5] [1,4] [2,3] [3,2] [4,1] [5,0]
流程图

粉红色的是标注为每次大循环的开始处

标注内层循环初始化的是该循环刚要开始时候的数据

PS：图片很多，过程很详细

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例代码
// i记录了次数和每一次输出开始的点的row
// 0 2 4
for (int i = 0; i < matrix.length; i+=2) {
    // 第一个输出的数字的column坐标开头都是0
    // [0,0][2,0][4,0]
    int j = 0;
    // 第一个内循环是左下角往右上角方向的
    // k（row）从i自减
    // j（column）自增到row到0
    for (int k = i; k >= 0; k--) {
        System.out.print(matrix[k][j++]+" ");
    }
    // 记录结束位置
	int end=j;
    // 如果n是奇数，在最后一次大循环中就不会有这个小循环了
    if(j >= matrix.length){
        break;
    }
    // 第二个内循环是右上角往左下角方向的
    // k（row）从0开始自增到end
    // j（column）自减到k到end
    for (int k = 0; k <= end; k++) {
        System.out.print(matrix[k][j--]+" ");
    }
}
连续法

把这些路径当作是连续的

维护一个[rowIndex,columnIndex]来走这一条连续的路径

示例代码
int row = matrix.length;
int column = matrix[0].length;
int whole = row * column;
int counter = 0;
int rowIndex = 0;
int columnIndex = 0;
// 只要计数器比一半少，就说明还没走完
while (counter < whole / 2) {
    while (rowIndex >= 0) {
        System.out.println(matrix[rowIndex--][columnIndex++]);
        counter++;
    }
    // 复位
    rowIndex = 0;
    while (columnIndex >= 0) {
        System.out.println(matrix[rowIndex++][columnIndex--]);
        counter++;
    }
    // 复位
    columnIndex = 0;
}
芝麻\n
关注
  • 11
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
矩阵的之字型遍历
guoziqing506的博客
06-07 2048
题目描述：给你一个包含 m x n 个元素的矩阵 (m 行, n 列), 求该矩阵的之字型遍历。 样例：对于如下矩阵： [   [1, 2,  3,  4],   [5, 6,  7,  8],   [9,10, 11, 12] ] 返回 [1, 2, 5, 9, 6, 3, 4, 7, 10, 11, 8, 12] 首先，先说明一下题目的意思。其实是以45度角方向遍历
矩阵的遍历
qq_40834200的博客
05-07 2863
/*Description 给出一个n*n的矩阵，如： 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 对它进行回形遍历的顺序为：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Input 测试数据有多组，第1行是测试数据的组数T。每组的第1行是正整数n（1<n<10）， 后跟n行，每行n个整数。数据之间由空格分隔。...
矩阵遍历（DFS、BFS、并查集）
qq_35789269的博客
07-19 1664
有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。 省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。 给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。 返回矩阵中 省份 的数量。 示例 1： 输入：isConn.
矩阵的遍历--按行、按列、蛇形
学习使我快乐
02-02 5213
这里有一个假设：  在图像处理等领域中，二维矩阵已经按照行的方式存放在了一维数组mat中了。  矩阵的高记为height，宽记为width；  1.按行遍历 for (int i = 0; i < height; ++i) for (int j = 0; j < width; ++j) mat[i*width + j]; 2.按列遍
图的遍历（上）——邻接矩阵表示
戴璞微的学习之路
09-08 2297
概述图作为数据结构书中较为复杂的数据结构，对于图的存储方式分邻接矩阵和邻接表两种方式。在这篇博客中，主要讲述邻接矩阵下的图的深度优先遍历（DFS）与广度优先遍历（BFS）。广度优先遍历（BFS）BFS 算法的思想是:对一个无向连通图,在访问图中某一起始顶点 v 后,由 v 出发,依次访问 v 的所有未访问过的邻接顶点 w1, w2, w3, …wt;然后再顺序访问 w1, w2, w3, …wt 的
PHP遍历二维数组的代码
10-28
首先，让我们深入理解如何遍历二维数组。有两种主要的方法：`foreach`循环和`for`循环。每种方法都有其适用的情况和优缺点。 1. **`foreach`循环遍历二维数组**： `foreach`循环是PHP中遍历数组的一种便捷方式，...
go for range遍历二维数组的示例
01-03
go for range 遍历二维数组 var arry [2][3] int for index,_ := range arry { fmt.Print(index) } 运行结果： 0 1 没有遍历所有的6个元素。 二维数组 arry 可以理解为：拥有两个 一维数组元素 的一维数组，所以...
使用vue中的v-for遍历二维数组的方法
08-27
本篇文章将详细介绍如何在Vue中利用`v-for`遍历二维数组。 首先，我们要了解二维数组的基本概念。二维数组可以看作是由多个一维数组组成的数组，每个一维数组之间是并列关系。在JavaScript中，我们可以这样定义一个...
C#使用foreach语句遍历二维数组的方法
09-03
本节将深入探讨如何使用`foreach`语句遍历二维数组，以及它相对于传统的`for`循环遍历的优势。 1. `foreach`语句基础 `foreach`语句的语法如下： ```csharp foreach (type variable in collection) { // code to ...
java二维数组遍历的2种代码
08-25
在Java编程中，二维数组是一种常见的数据结构，遍历二维数组是数组操作的基本步骤。今天，我们将详细介绍Java二维数组遍历的两种代码实现。 第一种方法：双重for循环 在Java中，我们可以使用双重for循环来遍历二维...
二维数组遍历
12-12
随意写的一个文档。
矩阵遍历、图片遍历算法
weixin_43452554的博客
06-05 454
矩阵遍历、图片遍历算法 常用到一个移动矩阵 leetcode54题 class Solution { private: int dxy[4][2] = {{0,1},{1,0},{0,-1},{-1,0}}; public: vector<int> spiralOrder(vector<vector<int>>& matrix) { int m = matrix.size(); if(m == 0) return {
遍历矩阵每一行穷举_计算矩阵中全1子矩阵的个数
weixin_39895096的博客
12-11 439
前言最近被我大哥安利了一道算法题, 这道题说难, 还不至于我做不出来, 说简单吧, 我还想不到最优解, 等把最优解告诉我之后, 我还正好能理解. 我甚至曾经怯怯的认为, 这题就是我哥专门给我找的, 嘿嘿, 心中说不出的小欢喜.题来了, 此题出自力扣, 原题链接:https://leetcode-cn.com/problems/count-submatrices-with-all-ones/描述: ...
算法-矩阵遍历问题专辑
qq_23594799的博客
04-19 806
算法-矩阵遍历问题专辑1、螺旋矩阵2、旋转图像3、搜索二维矩阵 II4、搜索二维矩阵 1、螺旋矩阵 54. 螺旋矩阵 给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。 示例 1: 输入: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 输出: [1,2,3,6,9,8,7,4,5] 示例 2: ...
遍历矩阵的几种方式
weixin_43886143的博客
10-15 3344
1.回形遍历 2.对角线遍历(leetcode 498. Diagonal Traverse) class Solution { public: vector<int> findDiagonalOrder(vector<vector<int>>& matrix) { vector<int> res; i...
二维数组的遍历
qq_39345059的博客
10-26 1816
package org.westos_02_二维数组; /*  * 如何遍历二维数组  *   * 外层循环:二维数组长度  * 内存循环:一维数组的长度  * */ public class Array2Test { public static void main(String[] args) { //定义二维数组,静态给出 int[][] arr = {{1,2,3},{4
C#Matrix矩阵类的实现
qq_46044233的博客
04-23 3870
C#矩阵类 Matrix.cs 想当初真的是绞尽脑汁写的代码，这是我算法与数据结构的作业 public class Matrix { private int[] items; private int rows, cols; public Matrix(int nRows, int nCols) ......
二维矩阵针对不同问题的遍历思路（算法）
weixin_44153921的博客
12-01 856
二维数组遍历方式常常为从左上角开始，但是针对不同情节，采用其他的遍历思路往往有更好的效果，避免了暴力解题。
torch.enisum爱因斯坦求和
养猪的纺织工
11-20 610
初次学习用于记录 1.转置 Bij = Aij import torch import tsensor h = torch.Tensor([[1,2],[3,4]]) with tsensor.clarify(): h = torch.einsum('ij->ji',h) print(h) 输出：tensor([[1., 3.], [2., 4.]]) 2.全部元素求和 h = torch.Tensor([[1,2],[3,4]]) with tsensor.clarify():
python遍历二维矩阵
最新发布
05-17
可以使用两个for循环实现对二维矩阵的遍历。示例代码如下： ```python matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] for i in range(len(matrix)): for j in range(len(matrix[i])): print(matrix[i][j], end=' ') print() ``` 输出结果为： ``` 1 2 3 4 5 6 7 8 9 ``` 其中，外层循环变量 `i` 遍历每一行，内层循环变量 `j` 遍历每一列。通过 `matrix[i][j]` 可以访问二维矩阵中的每一个元素。注意，我们在内层循环结束后需要换行，否则输出结果会变成一行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芝麻\n

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值