Javascript 比较数组以检查序列

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

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

难道没有更有效的方法来实现这一点吗

我应该提到，数组的初始集合可以包含重复值，例如：

[[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]

或

6

匹配到

array[I][0]

。所以容器总是以序列结束，比如

2,4,6,8

或

6,8

或

4,6,8

，等等。

对于每个数组，查看是否有其他数组以该数组的最后一个值开始，在之前或之后

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容器=[]；
对于（变量i=0；i

如果您只查看后面的子数组，那么只需在下一个索引处启动内部循环

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

var容器=[]；
对于（变量i=0；i

for（变量i=1；i

对于记录，这意味着创建一个单独的索引，它是一个字母到字母的映射：

var stringArray=[
[a'，b'，c']，
[c]、[d]、[e]，
[c]、[d]、[e]，
['e'，'f'，'g']，
['g'、'h'、'i']
];
var numberArray=[
[2, 3, 4],
[4, 5, 6],
[6, 7, 8],
[8, 9, 10]
];
//此实现假定没有循环或分支
函数链搜索（数组，开始）{
var容器=[start]；
var map=newmap（）；
var指数，内部，第一，最后；
无功电流=启动；
//在O（N）中构造元素到元素的映射
对于（索引=0；索引log（chainSearch（numberArray，6.join（））您也可以尝试以下方法：

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

哦，天哪，这是什么新鲜事？单独创建一个索引：一个字母到一个字母的映射。问题还不错。我只是向下滚动到一个四重嵌套的for循环，然后思考可能有两三次我必须做这样的事情。好吧，你总是为给定的值寻找对应的第一个值，然后“向后”建立结果——“循环”的可能性有多大？”还是在第一个/最后一个位置有多个相同的值？@Anthony我相信他的意思是像
[a，b，c]，[c，d，e]，[e，c，a]
。如果您从
a
开始，您当前的方法也永远不会结束。这一次的预期输出是什么？这并不能回答问题。他只想包含与已匹配原始数组的其他数组相匹配的数组。我已经尝试过类似于顶部示例的方法，但这种方法的问题是，如果我找到匹配项，我还需要将匹配项与数组的其余部分进行比较；换句话说，如果
array[0][2]
或
c
与
array[1][0]
或
c
匹配，那么我需要将
array[1][2]
或
e
与其余数组进行比较。这有意义吗？是的，它是一个外循环和一个内循环，所以它会将每个数组与每个数组进行比较。len*len比较的数量。如果您只是在寻找第一个匹配项，那么您可以在将内部循环添加到容器{container.push（）；break；}后简单地中断内部循环。如果您无法描述家庭作业的问题集，请不要对响应进行向下投票assignment@Steve我没有在这条线上投过任何反对票。。。但我相信你误解了我的问题/情景，其实。。。这个PHP函数的JS等价物是什么？值得注意的是，我认为你误解了我的问题。我不是将
array
与
container
进行比较，而是将
array[a][2]
与
array[z][0]
进行比较，如果
array[a][2]===array[z][0]
则将
array[a][2]
添加到
container
container

数组，然后将

array[z][2]

与

进行比较

要想了解更多比赛信息，我可能得好好玩玩，坐下来真正理解它。

newmap（）

是否创建了某种原型对象？我知道

map（）？我从未见过
地图。
（让我想起
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;
  }
}

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