Javascript 用堆栈展平阵列

我试图用一个堆栈（或者更确切地说，在本例中是在结果数组中拼接，而不是从堆栈中添加/删除）将一个数组迭代地展平到一个特定的深度（不是出于任何实际原因，而是为了学习）

到目前为止我有

function flatten(arr, depth = 1) {

    let flat = [];
    let i = 0;

    let d = depth;

    for (let elem of arr) {
        flat.push(elem);
        d = depth;

        while(i < flat.length) {
            if (Array.isArray(flat[i]) && d !== 0) {
                flat.splice(i, 1, ...flat[i]);
                d--;

            } else {
                i++;
            }
        }


    }

    return flat;
}

函数展平（arr，深度=1）{
let flat=[]；
设i=0；
设d=深度；
对于（让arr的元素）{
平推（elem）；
d=深度；
而（i

但是如果我有一个像[[3]、[4]、[5]、[6]这样的等级，它就会下降，因为一旦进入“3”的深度，它就不会后退

我能做个简单的修改吗

我使用的原始数组是

展平（[[1]，2，[[3]，'ddd'，[4[5]]]，2）

，其中我希望结果是[1,2,3，'ddd'，4[5]]

---

如果我正常使用堆栈实现它，我也会遇到同样的问题。

我认为使用

concat

和

reduce

可以非常干净地完成：

常数展平=（数组，深度）=>{
if（！depth）返回数组；
而（深度>0）{
array=array.reduce（（前，当前）=>pre.concat（当前），[]）；
深度--；
}
返回数组；
}
常数平坦=平坦（[1,2,a'，3]，[4,6,4]，[3,1,3]，[a'，2,b']，'c'，3,4]，2）；
console.log（平面）

我认为使用

concat

和

reduce

可以非常干净地完成：

常数展平=（数组，深度）=>{
if（！depth）返回数组；
而（深度>0）{
array=array.reduce（（前，当前）=>pre.concat（当前），[]）；
深度--；
}
返回数组；
}
常数平坦=平坦（[1,2,a'，3]，[4,6,4]，[3,1,3]，[a'，2,b']，'c'，3,4]，2）；
console.log（flat）

将深度从2更改为3不会得到您期望的结果吗？也许您在函数中的深度值只是“关了一个”？不，它似乎存在的问题是，一旦它上升了一个深度，它就再也不会变回原来的深度，所以如果我有

[[1]，2，[3'，ddd'，[4，[5]]

它是有效的-但是如果我把3放在一个数组中，那么它似乎需要上升一个深度，当它达到4时，它不会增加4，而是增加[4，[5]]你应该试试递归！据我所知，如果你想要一个深度限制，你还需要跟踪你在每个深度的位置，以便你知道如何退出。递归隐式地为你跟踪，但你没有使用递归，所以你必须自己做。（另外，如果不设置深度限制，我认为有一种方法可以不跟踪。）我正在尝试这样做-这就是d所做的。对于主数组中的每个新项（For of循环）d将是传递的深度，因为它实际上是第一级，然后当我推到输出数组时，我会减小d。将深度从2更改为3不会得到您期望的结果吗？也许您在函数中的深度值只是“关闭1”不，它似乎存在的问题是，一旦它上升了一个深度，它就再也不会变回来，所以如果我有

[[1]，2，[3，'ddd'，[4，[5]]]

它会工作-但是如果我把3放在一个数组中，那么它似乎会上升一个深度，当它达到4时，它不会增加4，而是增加[4，[5]]你应该试试递归！据我所知，如果你想要一个深度限制，你还需要跟踪你在每个深度的位置，以便你知道如何退出。递归隐式地为你跟踪，但你没有使用递归，所以你必须自己做。（另外，如果不设置深度限制，我认为有一种方法可以不跟踪。）我正在尝试这样做-这就是d所做的。对于主数组中的每个新项（For of循环）d将是传递的深度，因为它实际上是第一级，然后当我推到输出数组时，我会减小d。这是一种很好的方法，但问题是复杂度将是n^depth，因为你会减少已经展平的项。所以最坏的情况（我想）这将是一个已经扁平化的数组，我认为使用堆栈方法可以得到线性时间。嗯，我相信如果你迭代

n

项

depth

次，你可以得到

n*depth

迭代。除非

depth

意味着自由增长，否则它本身就是线性的。这是一种简洁的方法，但问题是com复杂度将是n^depth——因为你将减少已经扁平化的项目。所以最坏的情况（我认为）这将是一个已经扁平化的数组，我认为使用堆栈方法可以得到线性时间。嗯，我相信如果你迭代

n

项

depth

次，你就会得到

n*depth

次迭代。除非

depth

意味着自由增长，否则它本身就是线性的。