求二叉樹的深度，從根節點到葉子節點的最大值，以及最大路徑(python代碼實現)

首先定義一個節點類，包含三個成員變量，分別是節點值，左指針，右指針，如下代碼所示：

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

接下來就是二叉樹的相關工作：

1)初始化一棵二叉樹

class Solution(object):
    def __init__(self):
        root = Node(6)
        B = Node(4)
        root.left = B
        C = Node(7)
        root.right = C
        D = Node(1)
        B.left = D
        E = Node(2)
        B.right = E
        F = Node(3)
        C.left = F
        G = Node(5)
        C.right = G
        H = Node(6)
        I = Node(8)
        D.left = H
        E.left = I
        self.root = root
        self.max_value = 0
        self.path = []

2) 求二叉樹的深度(高度)

    def max_depth(self,root):
        if root == None:
            return 0
        if (root.left != None) & (root.right != None):
            return max(1 + self.max_depth(root.left), 1 + self.max_depth(root.right))
        elif (root.left != None) & (root.right == None):
            return 1 + self.max_depth(root.left)
        elif (root.left == None) & (root.right != None):
            return 1 + self.max_depth(root.right)
        else:
            return 1

3）求根節點到葉子節點的最大路徑值

    def max_sum(self, root, Sum):
        if root == None:
            return self.max_value
        if (root.left != None) & (root.right != None):
            self.max_sum(root.left, Sum + root.value)
            self.max_sum(root.right, Sum + root.value)
        elif (root.left != None) & (root.right == None):
            self.max_sum(root.left, Sum + root.value)
        elif (root.left == None) & (root.right != None):
            self.max_sum(root.right, Sum + root.value)
        else:
            if (Sum + root.value) > self.max_value:
                self.max_value = Sum + root.value

4）求根節點到葉子節點的最大路徑值對應的路徑

    def FindPath(self, root, expectNumber):
        ans = []  # 所有路徑的集合
        if root == None:
            return ans

        def iterpath(root, expectNumber, dir=[]):
            if expectNumber > root.value:
                dir.append(root.value)  # dir保存當前路徑（不一定是符合要求的路徑）
                # 分別在左右子樹中尋找並更新期望值
                if root.left != None:
                    iterpath(root.left, expectNumber - root.value, dir)
                if root.right != None:
                    iterpath(root.right, expectNumber - root.value, dir)
            elif expectNumber == root.value:
                dir.append(root.value)
                if root.right == None and root.left == None:  # 如果節點的值與期望值相同，則判斷節點是否為葉子結點，如果是葉子結點則是符合條件的路徑
                    tmp = dir[:]
                    ans.append(tmp)
            else:
                dir.append(0)
            dir.pop()  # ！！！！！！！！！！！！！

        iterpath(root, expectNumber)
        return ans

求二叉樹的深度，從根節點到葉子節點的最大值，以及最大路徑的完整代碼如下：

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

class Solution(object):
    def __init__(self):
        root = Node(6)
        B = Node(4)
        root.left = B
        C = Node(7)
        root.right = C
        D = Node(1)
        B.left = D
        E = Node(2)
        B.right = E
        F = Node(3)
        C.left = F
        G = Node(5)
        C.right = G
        H = Node(6)
        I = Node(8)
        D.left = H
        E.left = I
        self.root = root
        self.max_value = 0
        self.path = []

    def max_depth(self,root):
        if root == None:
            return 0
        if (root.left != None) & (root.right != None):
            return max(1 + self.max_depth(root.left), 1 + self.max_depth(root.right))
        elif (root.left != None) & (root.right == None):
            return 1 + self.max_depth(root.left)
        elif (root.left == None) & (root.right != None):
            return 1 + self.max_depth(root.right)
        else:
            return 1

    def max_sum(self, root, Sum):
        if root == None:
            return self.max_value
        if (root.left != None) & (root.right != None):
            self.max_sum(root.left, Sum + root.value)
            self.max_sum(root.right, Sum + root.value)
        elif (root.left != None) & (root.right == None):
            self.max_sum(root.left, Sum + root.value)
        elif (root.left == None) & (root.right != None):
            self.max_sum(root.right, Sum + root.value)
        else:
            if (Sum + root.value) > self.max_value:
                self.max_value = Sum + root.value

    def FindPath(self, root, expectNumber):
        ans = []  # 所有路徑的集合
        if root == None:
            return ans

        def iterpath(root, expectNumber, dir=[]):
            if expectNumber > root.value:
                dir.append(root.value)  # dir保存當前路徑（不一定是符合要求的路徑）
                # 分別在左右子樹中尋找並更新期望值
                if root.left != None:
                    iterpath(root.left, expectNumber - root.value, dir)
                if root.right != None:
                    iterpath(root.right, expectNumber - root.value, dir)
            elif expectNumber == root.value:
                dir.append(root.value)
                if root.right == None and root.left == None:  # 如果節點的值與期望值相同，則判斷節點是否為葉子結點，如果是葉子結點則是符合條件的路徑
                    tmp = dir[:]
                    ans.append(tmp)
            else:
                dir.append(0)
            dir.pop()  # ！！！！！！！！！！！！！

        iterpath(root, expectNumber)
        return ans

if __name__ == '__main__':
    binary_tree = Solution()
    max_depth = binary_tree.max_depth(binary_tree.root)
    binary_tree.max_sum(binary_tree.root, 0)
    path = binary_tree.FindPath(binary_tree.root, binary_tree.max_value)
    print("二叉樹的最大深度(高度)", max_depth)
    print("從根節點到葉子節點的路徑和最大值", binary_tree.max_value)
    print("從根節點到葉子節點的最大路徑", path)