Javascript 如何使用递归将元素插入数组中的所有位置？

我需要使用递归完成以下任务：

声明一个函数

insert_all_positions

，该函数接受以下参数：一个元素x和一个数组arr。函数必须返回一个数组数组，每个数组对应于arr，其中x插入到可能的位置。也就是说，如果arr是长度N，则结果是具有N+1个数组的数组

例如，

insert_all_positions（10[1,2,3]）

的结果是数组：

[[10,1,2,3],
[1,10,2,3],
[1,2,10,3],
[1,2,3,10]]

到目前为止，我有以下代码：

function insert_all_positions (x, arr) {
    if (arr.length === 1) {
        return arr.concat(x)
    }
    else {

    }
}

---

您不必使用递归来实现这一点。但此函数应返回您要查找的内容：

函数插入所有位置（x，arr）{
常量数组=[]；
对于（设i=0；i您不必使用递归来执行此操作。但此函数应返回您要查找的内容：

函数插入所有位置（x，arr）{
常量数组=[]；
对于（设i=0；i您可以通过克隆使用递归，并在索引（
i
）处添加
x
元素，然后使用相同的参数和递增的
i
）调用函数：


函数插入所有位置（x、arr、i=0）{
const clone=[…arr]//克隆阵列
clone.splice（i，0，x）//在位置i添加项
返回iconsole.log（result）
您可以通过克隆来使用递归，并在索引（
i
）处添加
x
元素，然后使用相同的参数和递增的
i
调用函数：


函数插入所有位置（x、arr、i=0）{
const clone=[…arr]//克隆阵列
clone.splice（i，0，x）//在位置i添加项
返回iconsole.log（result）
您可以将结果添加为可以传入的参数。然后您将能够执行以下操作：

（终止步骤）如果结果等于N+1，则表示已生成所有数组，即完成
为结果创建一个全新的数组
在适当位置插入
x
创建一个新数组

您可以使用以下事实：
x
的正确位置是结果的当前长度-首先是
0
，下次是
1
，等等

使用上面创建的数组构造一个新结果
（递归步骤）调用
insert_all_position
将新结果作为参数提供
这个看起来像这样


//最初为'result'创建一个空数组
函数插入所有位置（x，arr，result=[]）{
//终止-我们结束了
if（arr.length+1==result.length）
返回结果；
//从'arr'创建一个新数组，并在适当的位置添加'x'
const insertIndex=result.length；
常数newArray=arr
.slice（0，插入索引）
.concat（x）
.concat（arr.slice（insertIndex））；
//构建新的结果
常量newResult=[…结果，newArray]；
//递归调用
返回插入所有位置（x、arr、newResult）
}
console.log（插入所有位置（10、[1,2,3]）
您可以将结果添加为可以传入的参数。然后您将能够执行以下操作：

（终止步骤）如果结果等于N+1，则表示已生成所有数组，即完成
为结果创建一个全新的数组
在适当位置插入
x
创建一个新数组

您可以使用以下事实：
x
的正确位置是结果的当前长度-首先是
0
，下次是
1
，等等

使用上面创建的数组构造一个新结果
（递归步骤）调用
insert_all_position
将新结果作为参数提供
这个看起来像这样


//最初为'result'创建一个空数组
函数插入所有位置（x，arr，result=[]）{
//终止-我们结束了
if（arr.length+1==result.length）
返回结果；
//从'arr'创建一个新数组，并在适当的位置添加'x'
const insertIndex=result.length；
常数newArray=arr
.slice（0，插入索引）
.concat（x）
.concat（arr.slice（insertIndex））；
//构建新的结果
常量newResult=[…结果，newArray]；
//递归调用
返回插入所有位置（x、arr、newResult）
}
log（插入所有位置（10、[1,2,3]））
纯递归

递归从插入值
10
开始，作为空数组的最小数组

空数组是退出条件，如果没有更多可用的数组项，则只返回具有insert值的嵌套数组

对于每个递归步骤，将使用递归调用的结果扩展具有所需值的数组，并使用插入值或为递归调用剪切的数组的第一个值映射此数组

这里递归的结果是右下矩阵

result       comment
-----------  ----------------------------------

         10  insert(10, []), no more recursions


      10| 3  insert(10, [3])
      --+--
       3|10    > result of the recursion


   10| 2  3  insert(10, [2, 3])
   --+-----
    2|10  3    \ result of the recursion
    2| 3 10    /


10| 1  2  3  insert(10, [1, 2, 3])
--+--------
 1|10  2  3     \ result of the recursion
 1| 2 10  3     /
 1| 2  3 10    /


函数插入（x，数组）{
如果（！array.length）返回[[x]]；
返回[array，…insert（x，array.slice（1））].map（（a，i）=>[i？array[0]：x，…a]）；
}
插入（10，[1,2,3]）.forEach（a=>console.log（…a））；
纯递归

递归从插入值
10
开始，作为空数组的最小数组

空的