Question

我正在尝试编写一个函数，该函数返回二叉树不二进制搜索树中的最小值。这是我写的，这不正确。

def min(root, min_t): # min_t is the initially the value of root
    if not root:
            return min_t

    if root.key < min_t:
            min_t = root.key

    min(root.left, min_t)
    min(root.right, min_t)

    return min_t

我觉得我不太理解递归。我似乎无法弄清楚何时使用递归调用的return语句以及何时不使用。

感谢您的见解！

这是我提出的另一个，它有效，但它看起来效率不高：

n = []
def min_tree(root, n):
    if root:
        n += [(root.key)]
        min_tree(root.left, n)
        min_tree(root.right, n)
    return min(n)

思想？

Answer 1

迈克尔的答案解释了你可能应该解决这个问题的方式，但他没有解释你目前的尝试有什么问题。据我了解，您的策略是检查每个节点，并随时跟踪最低值，使用递归查找所有节点。一旦检查了所有节点，就会知道结果是整个树的最小值。这是一种非常有效的方法，除非参数不像您期望的那样完全有效，否则它会起作用。

Python按值传递参数，而不是通过引用传递参数。使用“min_t = root.key”为min_t分配值时，它仅在函数内部生效。函数的调用者没有看到新值。

您可以使用一些更简单的代码进行测试：

def add_one_to(x):
    x = x + 1
    print "add_one_to", x

x = 2
add_one_to(x)
print x

您可以看到运行代码时x在函数内增加但不在顶层。

当函数调用自身时，这也适用。每个调用都有自己的一组局部变量，并且在函数内部分配一个局部变量不会影响调用它的实例。

请注意，某些语言允许您通过引用传递参数。如果通过引用传递参数，那么在函数内部分配该参数也会影响调用者。如果Python是其中一种语言，你可以使min_t成为引用参数，并且你的函数可以正常工作。

虽然Python不直接支持引用参数，但您也可以将引用参数视为在调用函数时进入函数的值，并在函数完成时传递回调用者。你可以分别做这两件事。要将值传递回调用方，请返回该值。然后调用者可以将该函数分配给它的本地，并且您基本上已经通过引用传递了一个参数。

以下是您可以将其应用于上述示例的方法：

def add_one_to(x):
    x = x + 1
    print "add_one_to", x
    return x

x = 2
x = add_one_to(x)
print x

只需添加一个返回值和赋值，它就可以正常工作。

您也可以将此应用于原始功能：

def min(root, min_t): # min_t is the initially the value of root
    if not root:
            return min_t

    if root.key < min_t:
            min_t = root.key

    min_t = min(root.left, min_t)
    min_t = min(root.right, min_t)

    return min_t

我所做的只是在每次调用min（）之前添加“min_t =”并将return语句更改为最后返回min_t。（我想你可能还是要返回min_t.min是你的函数的名字，所以这没有多大意义。）我相信这个版本会有效。

编辑：尽管如此，你的min_tree函数的工作原理是n是一个列表，列表是可变对象。当我在谈论上面的“价值观”时，我真正的意思是“对象”。 python中的每个变量名都映射到特定对象。如果你有这样的代码：

def replace_list(x):
    x = [1, 2, 3]

x = [2]
replace_list(x)
print x

结果是[2]。因此，如果使用“x =”为x分配新值，则调用者将看不到它。但是，如果你这样做：

def replace_list(x):
    x.append(1)

x = [2]
replace_list(x)
print x

结果是[2,1]。这是因为你没有改变x的值; x仍然指向同一个列表。但是，该列表现在包含一个附加值。不幸的是，“+ =”运算符在这方面令人困惑。您可能认为“x + = y”与“x = x + y”相同，但在Python中并非总是如此。如果“x”是一种特定支持“+ =”的对象，那么该操作将修改对象。否则，它将与“x = x + 1”相同。列表知道如何处理“+ =”，因此使用+ =与列表将对其进行修改，但使用数字则不会。

你可以在不进行任何函数调用的情况下测试它：

x = [1, 2]
y = x
y += [3]
print x # [1, 2, 3]
print y # [1, 2, 3]
print x is y # True, x and y are the same object, which was modified in place

x = [1, 2]
y = x
y = y + [3]
print x # [1, 2]
print y # [1, 2, 3]
print x is y # False, y is a new object equal to x + [3]

x = 1
y = x
y += 2
print x # 1
print y # 3
print x is y # False, y is a new object equal to x + 2

Answer 2

对于这个特殊问题，您希望遍历整个树并返回看到的最小值。但总的来说，递归的基本原则是你再次调用函数，你会看到同一问题的修改版本。

考虑你的树：

    root
   /    \
left   right

当你在左子树上调用递归函数时，你会再次看到一棵树。因此，您应该能够使用相同类型的逻辑。

递归函数的关键是基本情况和递归步骤。在您的树示例中，基本情况不是在您找到最小值时（您怎么知道？），而是当您到达树的底部（也就是叶子）时。

而且，您的递归步骤是查看每个子问题（bin_min（左）和bin_min（右））。

最后一块是考虑返回值。不变量是你的函数返回了它看到的最小元素。因此，当你的递归调用返回时，你知道它是最小的元素，然后你需要返回的东西是三个可能选择中的最小元素（root，left_min和right_min）。

def min_bin(root):
    if not root:
        return MAX_VAL
    left_min = min_bin(root.left)
    right_min = min_bin(root.right)

    return min(left_min, right_min, root.val)

请注意，这是与@Rik Poggi不同的解决方案。他使用尾递归来优化它。

Answer 3

因为你自己想要解决这个问题比获得一个固定解决方案更多，所以这里有一些提示。首先，你不应该称之为min，因为当然你不能调用python的min来测试你的结果。正如Michael的回答提醒我的那样，你没有传递min_t，因为你可以测试root.key - 但我觉得它有帮助传入min_t以了解问题。

除此之外，你的第一行恰到好处;在这里做得很好。：

def tree_min(root, min_t): # min_t is the initially the value of root
    if not root:
            return min_t
    if root.key < min_t:
            min_t = root.key

现在你必须考虑要返回什么。基本上，有三种可能的最小值。第一个是min_t。第二个是right子树的最小值。第三个是left子树的最小值。获取后两个值（这是递归调用的来源），然后返回最小值。

Answer 4

这是一个查找最小元素的递归方法：

minelement = float("inf")
def minimum(self, root):
    global minelement
    if root:
        if root.data < minelement:
            minelement = root.data

        self.minimum(root.left)
        self.minimum(root.right)
    return minelement

在二叉树中查找最小值，Python

4 个答案: