这个复杂的递归代码是如何工作的？

Question

我试图理解这种递归。我知道递归在阶乘函数中是如何工作的，但是当涉及到像这样的复杂递归时，我感到很困惑。对我来说最令人困惑的部分是这段代码

str.split('').map( (char, i) => 
    permutations( str.substr(0, i) + str.substr(i + 1) )map( p => char + p))

首先，使用"abc"，例如，它将拆分为["a","b","c"]并通过map函数，然后通过第二个map函数将每个返回包装为a，b， c，分别。但是，我在递归部分很困惑。

我认为"a" 中的第一个递归值为str 为"abc" 将返回"bc"，第二次递归str 值为"bc" 将返回"c"，依此类推。

但是当我刚刚运行这段代码以查看清晰的递归时，它会返回

[ [ [ 'c' ], [ 'b' ] ], [ [ 'c' ], [ 'a' ] ], [ [ 'b' ], [ 'a' ] ] ]

这让我最困惑。我只是看不到这个递归如何返回这些值。谁能更详细地了解它的工作原理，例如逐步说明您的思维过程？

我是一个视觉学习者。感谢您的帮助。

function permutations(str) {
 return (str.length <= 1) ? [str] :
      // Array.from(new Set(
        str.split('')
              .map( (char, i) => 
                     permutations( str.substr(0, i) + str.substr(i + 1))
                           .map( p => char + p))
            //  .reduce( (r, x) => r.concat(x), [])
        //  ));
}

permutations('abc')

Answer 1

我更喜欢分析和创建递归解决方案的一种方法是像数学归纳法一样工作¹。

诀窍是显示该函数为我们的基本情况返回正确的值，然后显示如果它为我们的简单情况返回正确的值，它也会为我们当前的情况返回正确的值。然后我们知道它适用于所有值，只要每个递归调用都是针对一些更简单的情况并最终导致基本情况。

所以看看你的功能。我已对其进行了重新格式化以使讨论更容易，并且我已恢复您已注释掉的 reduce 呼叫。事实证明，正确执行此操作是必要的（尽管我们将在下面讨论更现代的替代方案。）您还注释掉了 Array .from (new Set( ... )) 包装器，它用于在您的字符串包含重复字符的情况下删除重复项。没有这个，"aba" 返回["aba", "aab", "baa", "baa", "aab", "aba"]。有了它，我们得到["aba", "aab", "baa"]，这更有意义。但这与我们的递归问题是分开的。

清理后的函数如下所示：

function permutations (str) {
  return (str .length <= 1) 
    ? [str] 
    : str 
        .split ('')
        .map ((char, i) => 
          permutations (str .substr (0, i) + str.substr (i + 1))
            .map (p => char + p)
        ) 
        .reduce ((r, x) => r .concat (x), [])
}

permutations('abc')

我们的基本情况非​​常简单，str.length <= 1。在这种情况下，我们产生[str]。这只有两种可能：字符串为空，我们返回['']，或者字符串只有一个字符，比如'x'，我们返回['x']。这些显然是正确的，所以我们继续进行递归调用。

假设我们通过了'abc'。 split 和 map 调用将其转换为等效的：

[
  permutations ('bc') .map (p => 'a' + p), 
  permutations ('ac') .map (p => 'b' + p),
  permutations ('ab') .map (p => 'c' + p),
]

但我们假设我们的递归适用于较小的字符串'bc'、'ac' 和'ab'。这意味着permutations('bc') 将产生['bc', 'cb']，其他类似，所以这相当于

[
  ['bc', 'cb'] .map (p => 'a' + p), 
  ['ac', 'ca'] .map (p => 'b' + p),
  ['ab', 'ba'] .map (p => 'c' + p),
]

这是

[
  ['abc', 'acb']
  ['bac', 'bca']
  ['cab', 'cba']
]

现在我们调用reduce，依次将每个数组连接到前一个结果上，从[]开始，得到

['abc', 'acb', 'bac', 'bca', 'cab', 'cba']

有一种更简洁的方法可以做到这一点。我们可以用一个flatMap 调用替换map 调用，然后是这个reduce 调用，如下所示：

function permutations (str) {
  return (str .length <= 1) 
    ? [str] 
    : str 
        .split ('')
        .flatMap ((char, i) => 
          permutations (str .substr (0, i) + str.substr (i + 1))
            .map (p => char + p)
        ) 
}

无论如何，我们已经展示了我们的归纳技巧。通过假设这适用于更简单的情况，我们表明它适用于当前情况。 （不，我们并没有严格地做到这一点，只是通过示例，但是用某种数学严谨性来证明这一点并不难。）当我们将它与它适用于基本情况的证明结合起来时，我们证明它适用于所有情况。这取决于我们的递归调用在某种程度上更简单，最终导致基本情况。在这里，传递给递归调用的字符串比我们提供的字符串短一个字符，因此我们知道最终我们将达到str .length <= 1 条件。因此我们知道它是有效的。

如果您重新添加 Array .from (new Set ( ... )) 包装器，这也适用于具有重复字符的情况。

---

¹ 您可能遇到过归纳，也可能没有遇到过归纳，您可能记得也可能不记得，但从本质上讲，它非常简单。这是一个非常简单的数学归纳论证：

我们将证明1 + 2 + 3 + ... + n == n * (n + 1) / 2，对于所有正整数，n。

首先，当n 是1 时，我们可以很容易地看出这是真的： 1 = 1 * (1 + 1) / 2

接下来我们假设该陈述对于n以下的所有整数都是正确的。

我们证明n 是这样的：

1 + 2 + 3 + ... + n 与1 + 2 + 3 + ... + (n - 1) + n 相同，即(1 + 2 + 3 + ... (n - 1)) + n。但是我们知道该语句对于n - 1 是正确的（因为我们假设它对于低于n 的所有整数都是正确的），所以1 + 2 + 3 + ... + (n - 1) 是，通过用n - 1 代替上面表达式中的n，等于(n - 1) * ((n - 1) + 1) / 2，简化为(n - 1) * n / 2。所以现在我们更大的表达式（(1 + 2 + 3 + ... (n - 1)) + n 与((n - 1) * n / 2) + n 相同，我们可以将其简化为(n^2 - n) / 2 + n，然后简化为(n^2 - n + (2 * n)) / 2 和(n^2 + n) / 2。这会影响n * (n + 1) / 2。

因此，通过假设小于n 的所有内容都为真，我们证明n 也为真。再加上当n 为1 时为真，归纳原理表明它对所有正整数n 都为真。

您可能已经看到归纳的表述略有不同：如果 (a) 对 1 成立，(b) 对于 n - 1 成立意味着它是真的对于n，然后(c)对于所有正整数n 都是正确的。 （这里的区别是我们不需要假设它对低于n 的所有整数都为真，仅适用于n - 1。）证明这两个模型的等价性很容易。而everything below 公式通常可以更方便地类比递归问题。

Answer 2

让我们检查一下permutations('abc')。

'abc' 转换为['a','b','c'] 用于映射

地图

一个

首先，char='a',i=0。 请注意，permutations(str.substr(0, i) + str.substr(i + 1)) 的意思是“获取除我正在查看的字符之外的所有字符的排列。在这种情况下，这意味着permutations('bc')。假设这给出了正确的输出['bc','cb']，因为是归纳的假设。

.map(p => char + p) 然后告诉我们将我们正在查看的字符 ('a') 添加到每个较小的排列中。这会产生['abc',acb']。

b

遵循相同的逻辑，char='b',i=1'。 permutations('ac') == ['ac','ca']。最终输出为['bac','bca']

c

遵循相同的逻辑，char='c',i=2'。 permutations('ab') == ['ab','ba']。最终输出为['cab','cba']。

因此函数的整体输出将是[['abc','acb'],['bac','bca'],['cab','cba']]...

Answer 3

这实际上是permutations 的一个非常不寻常的定义，我碰巧从未见过。

（好吧，事实证明，我实际上写过一次an answer，它几乎完全等同，而且仅在几年前......哦，我的）。

在伪代码中，通常看到的简单-递归定义是

perms [x, ...xs] = [ [...as, x, ...bs] | p <- perms xs, (as, bs) <- splits p]

但是这个是

perms2 xs = [ [x, ...p] | (as, [x, ...bs]) <- splits xs, p <- perms2 [...as, ...bs]]

（带有列表理解和模式；没有空列表案例；使用splits 的“自然” 定义，它构建了一个列表，其中包含将列表分成两部分的所有可能性）。

这里有一定的二元性……很有趣。而且不是“简单地”递归的。 :)

或者，用一些更明显的方式来实现命名函数，

perms [x, ...rest] = [ i | p <- perms rest, i <- inserts x p]
                   = flatMap (inserts x) (perms rest)

--- and this version, 
perms2 xs = [ [x, ...p] | (x, rest) <- picks xs, p <- perms2 rest]

另见：

• Understanding Peter Norvig's permutation solution in PAIP