Question

在线找到了此代码，该代码可用于在两个叶节点之间的树中找到最大值：

INT_MIN = -2**32

class Node: 
    def __init__(self, data): 
        self.data = data 
        self.left = None
        self.right = None

def maxPathSumUtil(root, res): 
    if root is None: 
        return 0

    if root.left is None and root.right is None: 
        return root.data 

    ls = maxPathSumUtil(root.left, res) 
    rs = maxPathSumUtil(root.right, res) 

    # If both left and right children exist 
    if root.left is not None and root.right is not None:      
        res[0] = max(res[0], ls + rs + root.data) 
        return max(ls, rs) + root.data 

    # If any of the two children is empty, return 
    # root sum for root being on one side 
    if root.left is None: 
        return rs + root.data 
    else: 
        return ls + root.data 

def maxPathSum(root): 
        res = [INT_MIN] 
        maxPathSumUtil(root, res) 
        return res[0]

我的问题是关于res[0]。为什么要使用仅包含一个值的列表来跟踪该节点的最大值？我尝试将其更改为常规整数，但无法正确更新。它返回错误的值。那么为什么在递归函数中使用具有单个值的列表而不是使用常规整数来跟踪最大值呢？

Answer 1

res列表充当原始对象的引用，因此，即使不返回该对象，该函数也可以对其进行变异。

_{注意：如果您熟悉C / C ++，这就像将使用<type> &<var_name>的引用传递给函数一样。}

以下示例对此进行了说明：

>>> def func(ref):
...  ref.append(1)
... 
>>> list_ = [1, 2, 3]
>>> func(list_)
>>> list_
[1, 2, 3, 1]

如所见，该函数在原位更改。

这主要是由于list_和ref引用了同一id。

>>> def func(ref):
...  ref.append(1)
...  print('Ref:', id(ref))
... 
>>> list_ = [1, 2, 3]
>>> id(list_)
4421621704
>>> func(list_)
Ref: 4421621704

由于list_和ref都引用相同的id，因此对该列表所做的任何更改都会传播到其他所有具有相同id的列表中。

>>> a = [1, 2, 3]
>>> b = a
>>> b.append(10)
>>> id(a), id(b)
(4421619848, 4421619848)
>>> a, b
([1, 2, 3, 10], [1, 2, 3, 10])

请注意，a和b具有相同的id，因此它们引用相同的列表对象。这证明了为什么将10附加到a。

在递归函数中跟踪和更新值

1 个答案: