Javascript 对角遍历二维阵列（矩阵）

所以我发现线程在对角遍历数组时非常有用。不过我被困在镜像上了。例如：

var m = 3;
var n = 4;
var a = new Array();
var b = 0;

for(var i = 0; i < m; i++) {
  a[i] = new Array(n);
  for(var j = 0; j < n; j++) {
    a[i][j] = b;
      b++;
  }
}

for (var i = 0; i < m + n - 1; i++) {
  var z1 = (i < n) ? 0 : i - n + 1;
  var z2 = (i < m) ? 0 : i - m + 1;
  for (var j = i - z2; j >= z1; j--) {
    console.log(a[j][i - j]);
  }
}

var m=3；
var n=4；
var a=新数组（）；
var b=0；
对于（变量i=0；i=z1；j--）{
log（a[j][i-j]）；
}
}

控制台显示为

[[0]，[4,1]，[8,5,2]，[9,6,3]，[10,7]，[11]

我想把它读成

[[8]，[4,9]，[0,5,10]，[1,6,11]，[2,7]，[3]

---

被难住了一段时间，它就像魔方一样好吧，我发现整个z1，z2逻辑有点不可读，所以我做的有点不同：

var m = 3;
var n = 4;
var a = new Array();
var b = 0;

for(var i = 0; i < m; i++) {
  a[i] = new Array(n);
  for(var j = 0; j < n; j++) {
    a[i][j] = b;
      b++;
  }
}

var out = new Array();
for (var i = 1 - m; i < n; i++) {
    var group = new Array();
    for (var j = 0; j < m; j++) {
        if ((i + j) >= 0 && (i + j) < n) {
            group.push(a[j][i + j]);
        }
    }
    out.push(group);
}
console.log(out);

这意味着对角线位于该网格上：

# # 0 1 2 3 # 4 5 6 7 # 8 9 10 11 # # # # 0 1 2 3 # 4 5 6 7 # 8 9 10 11 # # 现在我们只是在一个倾斜的矩形上循环，它看起来像是标准化的：

# # 0 1 2 3 # 4 5 6 7 # 8 9 10 11 # # # # 0 1 2 3 # 4 5 6 7 # 8 9 10 11 # # 现在，您会注意到，对于添加的每一行，您都会得到一个额外的列（从

#

开始），并且第一列现在会倾斜这个量（如果您想象将第一行固定到位并将下面的行向左滑动）。因此，对于我们的外部

for

循环（在列上），第一列实际上是旧的第一列

0

，减去

m

的行数，再加上

1

，得到

0-m+1

或

1-m

。最后一列实际上保持不变，因此我们仍然循环到

n

。然后，只需获取每一列并在

m

行上循环（内部

for

循环）

当然，这会给您留下一堆未定义的

代码（上面网格中的
#
s），但是我们可以用一个简单的
if
跳过它们，以确保我们的
i
和
j
在
m
和
n
范围内

可能比
z1
/
z1
版本的效率稍低，因为我们现在在冗余的
#
单元上循环，而不是预先计算它们，但这不会造成任何实际差异&我认为代码最终会更具可读性。
/*
/*
Initialize the 2-D array.
*/      
String array2D[] = { 
                    "mvjlixape",
                    "jhbxeenpp",
                    "hktthbswy",
                    "rwainuyzh",
                    "ppfxrdzkq",
                    "tpnlqoyjy",
                    "anhapfgbg",
                    "hxmshwyly",
                    "ujfjhrsoa" 
                    };
    // Print 2D array diagonally  for left top to right down
            for(int j = 0; j < array2D.length; j ++){
                for(int i = 0; i < array2D.length; i++){
                    if(i+j >= array2D.length)
                        break;
                    System.out.print(array2D[i].charAt(i+j));
                }
                System.out.println();
            }
            for(int j = 1; j < array2D.length; j ++){
                for(int i = 0; i < array2D.length; i++){
                    if(i+j >= array2D.length)
                        break;
                    System.out.print(array2D[i + j].charAt(i));
                }
                System.out.println();
            }

            // Print diagonally right top to left bottom diagonal
            for(int j = 0; j < array2D.length; j++){
                for(int i = j; i >= 0; i--){
                    System.out.print(array2D[j - i].charAt(i));
                }
                System.out.println();
            }
            for(int j = 1; j < array2D.length; j ++){
                for(int i = j; i < array2D.length; i++){
                    System.out.print(array2D[array2D.length - i + j - 1].charAt(i));
                }
                System.out.println();
            }

初始化二维数组。
*/      
字符串数组2d[]={
“mvjlixape”，
“jhbxeenpp”，
"hktthbswy",，
“Rwanuyzh”，
“ppfxrdzkq”，
“tpnlqoyjy”，
“anhapfgbg”，
“hxmshwyly”，
“ujfjhrsoa”
};
//从左上到右下对角打印二维阵列
对于（int j=0；j=阵列2d.长度）
打破
系统输出打印（array2D[i].charAt（i+j））；
}
System.out.println（）；
}
对于（int j=1；j=阵列2d.长度）
打破
系统输出打印（array2D[i+j].charAt（i））；
}
System.out.println（）；
}
//从右上到左下对角打印
对于（int j=0；j=0；i--）{
系统输出打印（array2D[j-i].charAt（i））；
}
System.out.println（）；
}
对于（int j=1；j
不，自学成才的程序员。。。不再上学了。也许我应该回去：我同意，这很好地解释了它背后的逻辑。非常感谢！在这里，我将打印阵列按对角线方向分为四部分。
/*
Initialize the 2-D array.
*/      
String array2D[] = { 
                    "mvjlixape",
                    "jhbxeenpp",
                    "hktthbswy",
                    "rwainuyzh",
                    "ppfxrdzkq",
                    "tpnlqoyjy",
                    "anhapfgbg",
                    "hxmshwyly",
                    "ujfjhrsoa" 
                    };
    // Print 2D array diagonally  for left top to right down
            for(int j = 0; j < array2D.length; j ++){
                for(int i = 0; i < array2D.length; i++){
                    if(i+j >= array2D.length)
                        break;
                    System.out.print(array2D[i].charAt(i+j));
                }
                System.out.println();
            }
            for(int j = 1; j < array2D.length; j ++){
                for(int i = 0; i < array2D.length; i++){
                    if(i+j >= array2D.length)
                        break;
                    System.out.print(array2D[i + j].charAt(i));
                }
                System.out.println();
            }

            // Print diagonally right top to left bottom diagonal
            for(int j = 0; j < array2D.length; j++){
                for(int i = j; i >= 0; i--){
                    System.out.print(array2D[j - i].charAt(i));
                }
                System.out.println();
            }
            for(int j = 1; j < array2D.length; j ++){
                for(int i = j; i < array2D.length; i++){
                    System.out.print(array2D[array2D.length - i + j - 1].charAt(i));
                }
                System.out.println();
            }