在Javascript中展平第n个嵌套数组的迭代解决方案

Question

谁能告诉我以下问题的迭代解决方案？我以递归方式解决了它，但在迭代解决方案中遇到了困难。 （Facebook 技术面试题）

Input: [1, {a: 2}, [3], [[4, 5], 6], 7]
Output: [1, {a: 2}, 3, 4, 5, 6, 7]

解决方案必须适用于第 n 个嵌套数组元素（即，如果有人修改了上面示例中的数组值/位置，它必须仍然有效）

递归解：

var flatten = function(input) {
    var result = [];

    input.forEach(function(element) {
        result = result.concat(Array.isArray(element) ? flatten(element) : element);
    });

    return result;
}

Answer 1

不确定在以前的答案中是否正确使用了“堆栈”方法。我认为它可以更简单，像这样：

function flatten(arr) {

  const result = [];
  const stack = [arr];

  while (stack.length) {
    const curr = stack.pop();
    if (Array.isArray(curr)) {
      for (let i = curr.length - 1; i >= 0; i--) {
        stack.push(curr[i]);
      }
    } else {
      result.push(curr);
    }
  }

  return result;
}

Answer 2

这是我的解决方案：

function flattenList(A) {
  let result = []
  for (let i=0; i < A.length; i++) {
    if (typeof A[i] == "object"){
      let item = reduceArray(A[i])
      result.push(...item)
    }else {
      result.push(A[i])
    }
  }
  return result
}

function reduceArray(arr){
  while(arr.some(Array.isArray)) {
    let item = arr.find(Array.isArray)
    let index = arr.indexOf(item)
    arr[index] = item[0]
  }
  return arr
}

Answer 3

这里有两种方法，递归和迭代，以及它们与 Array.flat 的比较。 也许它会帮助某人

const arrayToFlatten = [[1], [2, [3]], null, [[{}]], undefined];

// takes an array and flattens it recursively, default depth is 1 (just like Array.flat())
function flattenRecursive(arr, depth = 1) {
  let myArray = [];

  if (depth === 0){ // if you've reached the depth don't continue
    myArray = arr;
  } else if(!Array.isArray(arr)) { // add item to array if not an array
    myArray.push(arr);
  } else { // flatten each item in the array then concatenate
    arr.forEach(item => {
      const someNewArray = flattenRecursive(item, depth - 1);
      myArray = myArray.concat(someNewArray);
    });
  }
  
  return myArray;
}

// takes an array and flattens it using a loop, default depth is 1 (just like Array.flat())
function flattenIterative(arr, depth = 1) {
  let result = arr;

  // if an element is an array
  while(result.some(Array.isArray) && depth) {
    // flatten the array by one level by concating an empty array and result using apply
    result = [].concat.apply([], result);
    depth--; // track depth
  }

  return result;
}

console.log(arrayToFlatten.flat(2)); // ES^
console.log(flattenRecursive(arrayToFlatten, 2));
console.log(flattenIterative(arrayToFlatten, 2));

Answer 4

function flatten(array){
  for(var i=0;i<array.length;i++)
    if(Array.isArray(array[i]))
      array.splice.apply(array,[i,1].concat(array[i--]));
  return array;
}

这个就地解决方案比 Lupe 的更快，因为我已经删除了所有内部大括号（我在 concat 参数中内联了 i-- 来做到这一点）。

Answer 5

这是一种方法：

var input = [1, {a: 2}, [3], [[4, 5], 6], 7];
function flatten(input) {
    var i, placeHolder = [input], lastIndex = [-1], out = [];
    while (placeHolder.length) {
        input = placeHolder.pop();
        i = lastIndex.pop() + 1;
        for (; i < input.length; ++i) {
            if (Array.isArray(input[i])) {
                placeHolder.push(input);
                lastIndex.push(i);
                input = input[i];
                i = -1;
            } else out.push(input[i]);
        }
    }
    return out;
}
flatten(input);

解释：如果迭代嵌套结构，你只需要在移动到嵌套数组之前通过保存当前数组和位置来记住你之前的位置（这通常通过递归解决方案的堆栈）。

注意：如果您重复使用数组placeHolder 和lastIndex，您将不需要每次都重新创建它们。也许是这样的：

var flatten = function(){ 
    var placeHolder = [], lastIndex = [];
    placeHolder.count = 0;
    lastIndex.count = 0;
    return function flatten(input) {
        var i, out = [];
        placeHolder[0] = input; placeHolder.count = 1;
        lastIndex[0] = -1; lastIndex.count = 1;
        while (placeHolder.count) {
            input = placeHolder[--placeHolder.count];
            i = lastIndex[--lastIndex.count] + 1;
            for (; i < input.length; ++i) {
                if (Array.isArray(input[i])) {
                    placeHolder[placeHolder.count++] = input;
                    lastIndex[lastIndex.count++] = i;
                    input = input[i];
                    i = -1;
                } else out.push(input[i]);
            }
        }
        return out;
    }
}();

这再次更快（对于平面迭代），并且多次调用它的垃圾收集器问题更少。速度非常接近 Chrome 中递归函数调用的速度，比 FireFox 和 IE 中的递归快很多倍。

我在这里重新创建了 Tomalak 的测试，因为旧的 jsPerf 无法编辑：https://jsperf.com/iterative-array-flatten-2

Answer 6

这是一个原地变平的解决方案。

function flatten(arr) {
  var i = 0;

  if (!Array.isArray(arr)) {
    /* return non-array inputs immediately to avoid errors */
    return arr;
  }

  while (i < arr.length) { 
    if (Array.isArray(arr[i])) {
      arr.splice(i, 1, ...arr[i]);
    } else {
      i++;
    }
  }
  return arr;
}

此解决方案遍历数组，一次将每个元素展平一层嵌套，直到无法再展平为止。

Answer 7

相当简洁易读的算法：

function flatten(input) {
  var output = [];
  var todo = [input];
  var current;

  while(todo.length) {
    var current = todo.shift();
    if(Array.isArray(current)) {
       todo.unshift.apply(todo, current)
    } else {
      output.push(current);
    }
  }

  return output;
}

这个版本的性能比我的other answer 好，但仍然比James Wilkins' answer 慢很多。

JSBin

Tomalak's JSPerf

Answer 8

不同的迭代算法：

function flatten2(input) {
  var output = [];
  var todo = [input];
  var current;
  var head;

  while(todo.length) {
    var current = todo.shift();
    if(Array.isArray(current)) {
      current = current.slice();
      head = current.shift();
      if(current.length) {
        todo.unshift(current)
      }

      todo.unshift(head);
    } else {
      output.push(current);
    }
  }

  return output;
}

• 将所有元素放在一个堆栈上。
• 当堆栈不为空时，删除第一个元素。
  • 如果该元素是标量，则将其添加到输出中。
  • 如果该元素是一个数组，则将其拆分为头部（第一个元素）和尾部（其余元素）并将两者都添加到堆栈中。

正如Tomalak's JSPerf 所示，这很慢。

JSBin

Answer 9

这个怎么样？

inp = [1, {a: 2}, [3], [[4, 5], 6], 7]
out = inp;

while(out.some(Array.isArray))
  out = [].concat.apply([], out);

document.write(JSON.stringify(out));

Answer 10

有效，但不推荐：

var flatten = function(input) {
    return eval("[" + JSON.stringify(input).
    replace(/\[/g,"").replace(/\]/g,"") + "]");
}