Question

我试图在python中创建一个函数，但我根本不想改变BST类来做这件事。该函数用于查找根到具有最高深度的节点的路径的总和。如果有多个节点具有相同的深度，我会查找其中的最大总和并将其返回。

到目前为止（使用基本的BST课程）

类BTNode（对象）：

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

        self.data = data
        self.left = left
        self.right = right

在尝试制作一个算法来解决这个问题一段时间之后，我想出了一些上面的但他们失败了，我不知道如何编码它。

算法：

我认为这样可行：

我们从根开始。（基本情况我认为应该是每当我们遇到一个叶子时，如节点中没有孩子，所以没有左或右孩子，当左边没有右边，或右边没有左边时）< / p>

我首先检查左子树并获得它的深度，我们也将它称为depth_L以及总和。然后我检查正确的子树，我们将其称为depth_R，然后获得它的深度及其总和。

第二个条件是检查它们是否相等，如果它们相等则轻松，我们只取两个深度的最大值。否则，我们会看到谁拥有最高深度，并试图得到它的总和。

现在，我不知道怎么做才是一些事情。

1：我从来没有学过可选参数，所以我在尝试这个练习时试图避免这种情况，但我不认为我可以，而且我真的很感激有人可以给我看一些很酷的助手功能代替。

2：它不是右侧或左侧的总和，而是我需要的路径。考虑到一种获得正确路径的方法让人感到困惑

（继续我使用上述算法重新尝试）：

    def deepest_sum(self, bsum = 0, depth = 0):

        # The root is in every path so
        bsum = bsum + self.data
        depth = depth + 1
        # Base case whenever we find a leaf
        if self.left == None and self.right == None:
            result = bsum,depth

        elif self.left is not None and self.right is None:
            pass

        elif self.left is None and self.right is not None:
            pass

        else:

            # Getting the left and right subtree's depth as well as their
            # sums, but once we hit a leaf it will stop 
            # These optional parameters is messing me up
            if self.left:
                (sums1, depth_L) = self.left.deepest_sum(bsum,depth)
            if self.right:
                (sums2, depth_R) = self.right.deepest_sum(bsum,depth)

            # The parameter to check if they are equal, the highest goes through
            if depth_L == depth_R:
                result = max(sums1, sums2), depth_R
            else:
                if depth_L > depth_R:
                    result = sums1, depth_L
                else:
                    result = sums2, depth_R

        return result

坚持我提到的部分。下面是一个例子：

>>> BST(8, BST(7, BST(10), BST(11)), BST(6, BST(11), BST(9, None, BST(14)))

37  (depth 3 is the highest so 8 + 6 + 9 + 14 is the path)

对不起我把BST我忘了，它是一个二进制树而不是BST。

我知道我给了一个元组，但我总是可以帮助修复它，我只是觉得它更容易跟踪节点。

Answer 1

如果函数不需要是BTNode的方法，则可以简化实现。然后你可以跟踪深度＆amp; sum，迭代过去叶子并返回当前深度和总和。此外，如果您返回(depth, sum)元组，则可以使用max直接将它们相互比较：

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

def deepest_sum(node, depth=0, current=0):
    # Base case
    if not node:
        return (depth, current)

    depth += 1
    current += node.data

    return max(deepest_sum(node.left, depth, current), 
               deepest_sum(node.right, depth, current))

tree = BTNode(8, BTNode(7, BTNode(10), BTNode(11)), BTNode(6, BTNode(11), BTNode(9, None, BTNode(14))))
print(deepest_sum(tree))

输出：

(4, 37)

函数查找二叉搜索树的最深和

1 个答案: