如何在javascript中对角遍历数组[关闭]

【问题标题】：How do I traverse an array diagonally in javascript [closed]如何在javascript中对角遍历数组[关闭]
【发布时间】：2016-06-25 08:54:11
【问题描述】：

我有一个包含字符串的数组，我想对角遍历。
假设：

  • 每个字符串的长度相同。
  • 阵列可以是正方形或矩形，水平或垂直。

矩阵如下所示：

A B C D
E F G H
I J K L

我想得到（从左上到右下）：

A
EB
IFC
JGD
KH
L

和（从左下角到右上角）：

I
JE
KFA
LGB
HC
D

我已经有一段代码可以运行 3/4，但我似乎无法弄清楚我在做什么（错误）。 

//the array
var TheArray = ['ABCD','EFGH','IJKL'];

//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

我的代码将对角线分割成 4 个循环以获得所有对角线。它看起来像 2 个带有 if 的 for 循环，它不会循环未绑定的值。伪代码看起来有点像这样：

for(loop rows){
 var outputarray = [];
   for(loop columns){
      if(delimit for out of bound){
       var temprow = TheArray[something?];
       var tempvalue = temprow[something?];
       outputarray.push(tempvalue);
       }
   }
 //use values
document.getElementById("theDiv").innerHTML += outputarray.join("")+"<br>";
}

我希望有人可以帮助我。

【问题讨论】：

  • 只是出于好奇：您使用的是“字符串”数组还是数组数组？
  • @goodguy5 没关系，因为您可以像数组一样通过索引访问字符串。
  • @jcubic 准确地说，它是一个带有字符串的数组，而不是数组的数组，我正在使用索引从字符串中获取正确的值。
  • 家庭作业问题重复：Traverse an array diagonally 和 Traversing a 2D array matrix diagonally

标签： javascript arrays loops matrix iteration


【解决方案1】：

使用索引：

[i][j-i]

我从 0 到 M-1 的位置

j 从 0 到 i

而 j++

对于矩阵

类型数组[M][N]

但是，如果矩阵是矩形的，这可能会错过右下角的一些内容，您可能需要第二个带有 i 和 j 的嵌套 for 循环来捕获这些内容。

【讨论】：

    【解决方案2】：

    从左上到右下

    var array = ["ABCD","EFGH","IJKL"];

var Ylength = array.length;
var Xlength = array[0].length;
var maxLength = Math.max(Xlength, Ylength);
var temp;
for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
    temp = [];
    for (var y = Ylength - 1; y >= 0; --y) {
        var x = k - y;
        if (x >= 0 && x < Xlength) {
            temp.push(array[y][x]);
        }
    }
    if(temp.length > 0) {
        document.body.innerHTML += temp.join('') + '<br>';
    }
}

    （另见this Fiddle）

    从左下角到右上角

    var array = ["ABCD","EFGH","IJKL"];

var Ylength = array.length;
var Xlength = array[0].length;
var maxLength = Math.max(Xlength, Ylength);
var temp;
for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
    temp = [];
    for (var y = Ylength - 1; y >= 0; --y) {
        var x = k - (Ylength - y);
        if (x >= 0 && x < Xlength) {
            temp.push(array[y][x]);
        }
    }
    if(temp.length > 0) {
        document.body.innerHTML += temp.join('') + '<br>';
    }
}

    （另见this Fiddle）

    结合

    由于两者之间只有一条区别，您可以轻松地将它们组合成一个函数：

    var array = ["ABCD","EFGH","IJKL"];

function diagonal(array, bottomToTop) {
    var Ylength = array.length;
    var Xlength = array[0].length;
    var maxLength = Math.max(Xlength, Ylength);
    var temp;
    var returnArray = [];
    for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
        temp = [];
        for (var y = Ylength - 1; y >= 0; --y) {
            var x = k - (bottomToTop ? Ylength - y : y);
            if (x >= 0 && x < Xlength) {
                temp.push(array[y][x]);
            }
        }
        if(temp.length > 0) {
            returnArray.push(temp.join(''));
        }
    }
    return returnArray;
}

document.body.innerHTML = diagonal(array).join('<br>') +
                          '<br><br><br>' +
                          diagonal(array, true).join('<br>');

    （另见this Fiddle）

    【讨论】：

    • 如果你运行截图，你会看到它错过了最后一列的条目。
    • 如此接近，我尝试实现您的代码，它似乎没问题，它有效，我可以理解发生了什么。谢谢你。但是当数组中的行数超过字符串的长度时，就会出现一些问题。它不返回最后一个值。看到这个小提琴：jsfiddle.net/24xv3wvh/18
    • @viperia ：我刚刚解决了这个问题。你能用我最新更新的代码再试一次吗？！ ;-)
    • 谢谢，谢谢，谢谢。做到了。查看矩阵哪一侧更长的技巧做到了。
    【解决方案3】：

    这是我对“从左上到右下”的尝试：

    for (i=0; i<nbRows; i++) {
    x = 0; y = i;
    while (x < nbColumns && y >= 0) {
        print(array[x, y]);
        x++; y--;
    }
    print("\n");
}
for (i=1; i<nbColumns; i++) {
    x = i; y = nbRows - 1;
    while (x < nbColumns && y >=0) {
        print(array[x, y]);
        x++; y--;
    }
}

    需要进行一些调整以适应 JavaScript 语法。

    【讨论】：

      【解决方案4】：

      这可以解决问题，并将所需的结果输出到屏幕：

      var array = ['ABCD','EFGH','IJKL'];
var rows = array.length;
var cols = array[0].length;
for (var n = 0; n < cols + rows - 1; n += 1)
{
  var r = n;
  var c = 0;
  var str = '';
  while (r >= 0 && c < cols)
  {
    if (r < rows)
      str += array[r][c];
    r -= 1;
    c += 1;
  }
  document.write(str+"<br>");
}

      结果：

      A
EB
IFC
JGD
KH
L

      【讨论】：

      • 您可能想使用str.split('').reverse().join('');反转字符串
      • 这个和我做的基本一样。不过，我想我更喜欢你的。而你让我意识到我想象的数组是错误的（翻转了索引）
      【解决方案5】：

      这甚至适用于矩形矩阵：

      var array = ["ABCD", "EFGH", "IJKL"];
var arrOfArr = [];
var resultArray = [];
for (var i = 0; i < array.length; ++i) {
    arrOfArr.push(array[i].split(''));
}

var rows = arrOfArr.length;
var columns = arrOfArr[0].length;

var index = 0;

for (var i = 0; i < rows; ++i) {
    var k = 0;
    resultArray[index] = new Array();
    for (var j = i; j >= 0; --j) {
        resultArray[index].push(arrOfArr[j][k]);
        ++k;
        if ( k === columns) {
            break;
        }
    }
    resultArray[index] = resultArray[index].join('');
    ++index;
}

for (var j = 1; j < columns; ++j) {
    var k = rows - 1;
    resultArray[index] = new Array();
    for (var i = j; i < columns; ++i) {
        resultArray[index].push(arrOfArr[k][i]);
        --k;
        if ( k === -1) {
            break;
        }
    }
    resultArray[index] = resultArray[index].join('');
    ++index;
}
console.log(JSON.stringify(resultArray));

      【讨论】：

        【解决方案6】：

        试试这个

        var TheArray = ['ABCD', 'EFGH', 'IJKL'];
    //amount of rows
    var RowLength = TheArray.length;
    //amount of colums
    var ColumnLength = TheArray[0].length;

    var totalNoComb = RowLength + ColumnLength - 1;
    var combArr = new Array(totalNoComb);
    for (var i = 0; i < totalNoComb; i++) {
        combArr[i] = "";
        for (var j = RowLength-1; j >-1; j--) {
            if (i - j > -1 && i - j < ColumnLength)
                combArr[i] += TheArray[j][i-j];
        }
    }
    alert(combArr);

    for (var i = 0; i < totalNoComb; i++) {
        combArr[i] = "";
        for (var j = 0; j < RowLength; j++) {
            if (i - j > -1 && i - j < ColumnLength)
                combArr[i] += TheArray[ RowLength -1-j][i - j];
        }
    }
    alert(combArr);

        【讨论】：

          【解决方案7】：

          注意：这假定所有字符串的大小相同，或者至少与第一个字符串一样大。

          在二维数组（或在本例中为字符串数组）中，对角线的索引加起来就是对角线的编号（如行号）。 00、01 10、02 11 20 等

          使用这种方法，对角线“行”的数量（从零开始）等于最大索引的总和，或 (columnlength+rowlength-2) 的总和。

          因此，我的解决方案是遍历对角线行号并打印总和等于当前对角线行的所有索引对。

          var TheArray = ["ABCD","EFGH","IJKL"];
//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

var text = ''
for (i = 0; i <= (RowLength+ColumnLength-2); i++){
    for (x = 0; x<=i; x++){
    if (TheArray[i-x] && TheArray[i-x][x]){
        text += TheArray[i-x][x];
    }
  }
  text += "<br/>";
}

document.getElementById('text').innerHTML = text;

          JSFiddle Link

          【讨论】：

            【解决方案8】：

            两条对角线的完整解决方案：

            var TheArray = ['ABCD', 'EFGH', 'IJKL'];
var RowLength = TheArray.length;
var ColumnLength = TheArray[0].length;

// Diagonals
var diagonal = [[], []];
for (var i = 0; i < Math.min(RowLength, ColumnLength); i++) {
    diagonal[0].push({'row': 0-i, 'col': i});
    diagonal[1].push({'row': 0-i, 'col': 0-i});
}

// Entry points
// 1///
// 2///
// 3456
var points = [[], []];
for (var y = 0; y < RowLength; y++) {
    points[0].push({'row': y, 'col': 0});
}
for (var x = 1; x < ColumnLength; x++) {
    points[0].push({'row': RowLength - 1, 'col': x});
}

// Entry points
// \\\6
// \\\5
// 1234
for (var x = 0; x < ColumnLength; x++) {
    points[1].push({'row': RowLength - 1, 'col': x});
}
for (var y = RowLength - 2; y >= 0; y--) {
    points[1].push({'row': y, 'col': ColumnLength - 1});
}

var strings = [[], []];
for (var line = 0; line < diagonal.length; line++) {
    for (var point = 0; point < points[line].length; point++) {
        var inside = true;
        var index = 0;
        var string = '';
        while (inside && index < diagonal[line].length) {
            var row = points[line][point]['row'] + diagonal[line][index]['row'];
            var col = points[line][point]['col'] + diagonal[line][index]['col'];
            if (row >= 0 && row < RowLength && col >= 0 && col < ColumnLength) {
                string += TheArray[row][col];
                index++;
            } else {
                inside = false;
            }
        }
        strings[line].push(string);
    }
}

console.log(strings);

            【讨论】：

              【解决方案9】：

              另一个解决方案：

              function getAllDiagonal(array) {
    function row(offset) {
        var i = array.length, a = '';
        while (i--) {
            a += array[i][j + (offset ? offset - i : i)] || '';
        }
        return a;
    }

    var result = [[], []], j;
    for (j = 1 - array.length; j < array[0].length; j++) {
        result[0].push(row(0));
        result[1].push(row(array.length - 1));
    }
    return result;
}

var array = ['ABCD', 'EFGH', 'IJKL'];

document.write('<pre>' + JSON.stringify(getAllDiagonal(array), 0, 4) + '</pre>');

              【讨论】：

                猜你喜欢
                • 1970-01-01
                • 2021-03-23
                • 2021-09-14
                • 2019-04-14
                • 2023-02-20
                • 2021-12-15
                • 1970-01-01
                • 1970-01-01
                • 1970-01-01
                相关资源
                最近更新 更多
                热门标签
                Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode