函數查找二叉搜索樹的最深總和

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)