Question

假设我们有以下一组嵌套数组：

var array = [
              [a,b,c],
                  [c,d,e],
                      [e,f,g],
                          [g,h,i]
            ]

如果我们从[a,b,c]开始，并希望找到以c开头的任何嵌套数组，如果有，则将该数组的索引2的元素推送到新的已经保存c的数组，我们可以编写以下代码：

var container = [];
container.push(array[0][2]);

for (var i = 0; i < array.length; i++) if (array[0][2] === array[i][0]) container.push(array[i][2])

因此，{p> container最终会成为[c,e]。

足够简单。

但是，如果我们现在还要检查e是否与其他array[i][0]匹配，该怎么办？然后依此类推，直到我们检查了整个array并最终得到以下数组：[c,e,g,i]。

我要做的是查看任何给定数组的最后一个元素是否与任何其他数组的第一个元素匹配;如果是，则收集该数组中的最后一个元素，并检查该元素是否与任何其他嵌套数组的第一个元素匹配。

因此，如果我们从i开始，我们最终会得到[i]。

如果我们从元素g开始，我们最终会得到[g,i]。

现在我正在使用嵌套的for循环和if/else语句，如下所示：

for (var i = 0; i < array.length; i++) {
  if (element === array[i][0]) {
    container.push(array[i][2]);
    for (var ii = 0; ii < array.length; ii++) {
      if (array[i][2] === array[ii][0]) {
        container.push(array[ii][2]);
        for (var iii = 0; iii < array.length; iii++) {
          if (array[ii][2] === array[iii][0]) {
            container.push(array[iii][2])
            for (var iiii = 0; iiii < array.length; iiii++) {
              if (array[iii][2] === array[iiii][0]) {
                container.push(array[iiii][2])
              }
            }
          }
        }
      }
    }
  }
}

有没有更有效的方法来实现这一目标？

我应该提到初始数组可以包含重复的值，例如：[ [a,b,c], [a,b,c], [g,h,i], [x,y,z] ]或[ [a,b,c], [a,b,c], [c,d,e], [x,y,z] ]。

要启动我已经注意到我的当前方法会在上面的第二种情况下吐出不需要的结果，例如[c,e,c,e]，而不仅仅是[c,e]。

通过使用数字来思考这个问题可能更容易：

var array = [
              [2,n,4],
                  [4,n,6],
                      [6,n,8],
                          [8,n,10]
            ]

如果起始值为4，我会将array[1][2]或6推送到container，然后尝试匹配array[1][2]或{{1到6。因此，容器最终会成为array[i][0]或2,4,6,8或6,8等序列。

Answer 1

对于记录，这是@zerkms创建一个单独索引的意思，这是一个字母到字母的地图：

＆＃13;

NegativeArraySizeException

＆＃13;

这个实现的优点在于，即使演示使用基元（字符串和数字），这也适用于非基元的嵌套数组，假设您正在测试对相同对象的引用而不是相同的副本。

Answer 2

您也可以尝试这种方法：

function seq(source, result) {
        if (source.length === 1) 
            return result.concat(source[0][source[0].length - 1]);                        

        result = result || [];

        if (source[0][source[0].length - 1] === source[1][0]) 
             result = result.concat(source[1][0]);

        return seq(source.slice(1), result);
    }

    console.log(seq(array));

Answer 3

for (var i = 1; i < array.length; i++) {
  if (in_array(array[i][0], container)) { //if first element of current array matches any element in container
    //add it to container if it's not already there
    if (!in_array(array[i][2], container)) {
      container.push(array[i][2]);
    }
    //and then recheck all arrays to see if they match the new element
    i = 1;
  }
}

Answer 4

对于每个数组，在

之前或之后查看是否有任何其他数组以此数组的最后一个值开头

var container = [];
for (var i=0; i < ary.length; i++) 
   for (var j=0; j < ary.length; j++) 
       if (i != j && ary[i][2] == ary[j][0])
           container.push(ary[j][0]);

如果您只是查看后面的子数组，那么只需在下一个索引

处启动内部循环

var container = [];
for (var i=0; i < ary.length; i++) 
   for (var j=i+1; j < ary.length; j++) 
       if (i != j && ary[i][2] == ary[j][0])
           container.push(ary[j][0]);

比较数组以检查序列

4 个答案: