Question

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

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]);
  }
}

控制台读取[[0],[4,1],[8,5,2],[9,6,3],[10,7],[11]]

我希望阅读[[8],[4,9],[0,5,10],[1,6,11],[2,7],[3]]

被困了一会儿，就像一个魔方的＆gt; _＆lt;

Answer 1

好吧，我发现整个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);

将[[8], [4, 9], [0, 5, 10], [1, 6, 11], [2, 7], [3]]打印到控制台。

如何运作

你的矩阵构造给你一个像这样的矩形（你的a数组是行集）：

 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。然后它只是采取每个列和＆amp;循环遍历每个m行（内部for循环）。

当然，这会为您留下一堆undefined s（上面网格中的# s），但我们可以使用简单的if跳过它们，以确保我们的i＆amp; j属于m＆amp; n界限。

可能效率略低于z1 / z1版本，因为我们现在循环遍历冗余的#单元格而不是预先计算它们，但它不应该现实世界的差异＆amp;我认为代码最终会更具可读性。

Answer 2

/*
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阵列（矩阵）

2 个答案:

如何运作