返回在 Python 中递归创建的不同结果的列表

Question

最近我一直在处理 Python 中的一些递归问题，我必须使用递归生成可能的配置列表（即给定字符串的排列列表、子字符串列表等）。我很难找到最佳实践，也很难理解如何在递归中管理这种变量。

我将给出generate binary trees 问题的示例。我或多或少知道我必须在递归中实现什么：

1. 如果 n=1，则只返回一个节点。
2. 如果 n=3，则返回唯一可能的二叉树。
3. 对于 n>3，创建一个节点，然后探索可能性：左节点没有子节点，右节点没有子节点，两个节点都没有子节点。递归探索这些可能性。

现在我最难以想象的事情是我将如何准确地到达树木列表。目前我所做的做法是在函数调用中传递一个列表（作为参数）并且该函数将返回这个列表，但是问题是在调用递归函数以探索节点的可能性时的情况 3 它将是返回一个列表，而不是将节点附加到我正在构建的树上。当我在脑海中描绘递归树时，我想象一个“树”变量对每个树叶都是唯一的，并且这些树被添加到由“根”（即第一个）调用返回的列表中。但我不知道这是否可能。我想到了一个全局列表和递归函数不返回任何东西（只是附加到它），但我认为问题是在每次调用时函数都会收到变量的副本。

在这些递归情况下，我该如何处理生成组合和返回配置列表？虽然我举了一个例子，但答案越笼统越好。我也想知道在这方面是否有“最佳实践”。

Answer 1

目前我的做法是在函数调用中传递一个列表（作为参数），函数会返回这个列表

这不是解决递归问题的最纯粹的方法。如果您可以制作递归函数以解决子问题而不需要它必须使用的额外参数变量，那就更好了。所以递归函数应该只返回一个结果好像它是唯一的调用（由测试框架）。所以在这个例子中，递归调用应该返回一个带有树的列表。

或者，递归函数可以是一个不返回列表但产生单个值的子函数（在本例中为树）。然后调用者可以决定是否将其打包到列表中。这更像是pythonic。

对于示例问题，识别一些不变量也很重要。例如，很明显当 n 为偶数时没有解。至于递归方面：一旦你决定创建一个根，那么它的左右子树都会有奇数个节点。当然，这是针对此问题的特定观察，但寻找此类问题的属性很重要。

最后，同样重要的是查看相同的子问题是否会重复出现多次。在示例问题中肯定就是这种情况：例如，左子树有时可能与右子树具有相同数量的节点。在这种情况下，记忆将提高效率（动态编程）。

当递归函数返回一个列表时，调用者可以迭代该列表以检索其元素（示例中的树），并使用它们来构建满足调用者任务的扩展结果。在示例情况下，这意味着从递归检索的列表中获取的树作为子节点附加到新的根节点。然后这个新树被附加到一个 new 列表（与递归调用返回的无关）。这个新列表在很多情况下会更长，尽管这取决于问题的类型。

为了进一步说明解决这些问题的方法，这里有一个示例问题的解决方案：使用 main 函数进行递归调用，并使用记忆：

class Solution:
    memo = { 1: [TreeNode()] }
    
    def allPossibleFBT(self, n: int) -> List[Optional[TreeNode]]:
        # If we didn't solve this problem before...
        if n not in self.memo:
            # Create a list for storing the results (the trees)
            results = []
            # Before creating any root node, 
            #    decide the size of the left subtree.
            #    It must be odd
            for num_left in range(1, n, 2):
                # Make the recursive call to get all shapes of the
                # left subtree
                left_shapes = self.allPossibleFBT(num_left)
                # The remainder of the nodes must be in the right subtree
                num_right = n - 1 - num_left  # The root also counts as 1
                right_shapes = self.allPossibleFBT(num_right)
                # Now iterate the results we got from recursion and 
                #    combine them in all possible ways to create new trees
                for left in left_shapes:
                    for right in right_shapes:
                        # We have a combination. Now create a new tree from it
                        # by putting a root node on top of the two subtrees:
                        tree = TreeNode(0, left, right)
                        # Append this possible shape to our results
                        results.append(tree)
            # All done. Save this for later re-use
            self.memo[n] = results
        return self.memo[n]

使用列表推导可以使这段代码更紧凑，但它可能会降低代码的可读性。

Answer 2

不要将信息传递给递归调用，除非它们需要该信息来计算其本地结果。当你在没有副作用的情况下编写时，推理递归要容易得多。因此，与其让递归调用将其自己的结果放入列表中，不如编写代码以便使用递归调用的结果来创建返回值。

让我们举一个简单的例子，将一个简单的循环转换为递归，并用它来累积一个递增的整数序列。

def recursive_range(n):
    if n == 0:
        return []
    return recursive_range(n - 1) + [n]

我们以自然的方式使用函数：我们将信息与参数一起放入，将信息输出使用返回值（而不是参数的突变） .

在你的情况下：

现在我最难以想象的事情是我将如何准确地到达树列表。

所以你知道你想在过程结束时返回一个树列表。所以自然的方法是，你希望每个递归调用也这样做。

在这些递归情况下，我该如何处理生成组合和返回配置列表？虽然我举了一个例子，但答案越笼统越好。

递归调用返回子问题的结果列表。您可以使用这些结果来创建当前问题的结果列表。

您不需要考虑如何实现递归来编写递归算法。您无需考虑调用堆栈。你确实需要考虑两件事：

• 基本情况是什么？
• 问题如何递归分解？ （或者：为什么递归非常适合这个问题？）

问题是，递归并不特殊。进行递归调用就像调用任何其他函数，它会碰巧为您提供子问题的正确答案。因此，您需要做的就是了解解决子问题如何帮助您解决当前问题。