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

Question

我试图在python中创建一个函数，因为我根本不想更改BST类来执行此操作。 该功能是找到根到深度最大的节点的路径之和。 如果有多个具有相同深度的节点，我正在寻找最大深度并返回。

到目前为止，我得到了什么（使用基本的BST类）

类BTNode（object）：

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

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

在尝试制定一种算法解决了一段时间后，我提出了上面的几个，但是它们失败了，我不知道如何编码。

算法：

我认为这会起作用：

我们从根开始。 （我认为基本情况应该是当我们碰到叶子时，如节点中没有子节点，因此没有左子节点或右子节点，以及左无右或右无左）

我首先检查左子树并得到它的深度，我们将其与总和也称为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的方法，则可以大大简化实现。 然后，您可以跟踪深度和总和，迭代经过叶子并返回当前的深度和总和。 另外，如果返回(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)