【猿辅导】（数据开发工程师-面试）求二叉树的最大链路和【Python】

题目描述

已知一个满二叉树如下，最所有链路的最大链路和

  		      4
           /     \
        2          7
     /     \     /    \
    9       2   3       1

输出

15

关于二叉树

二叉树的三种遍历方式：

• 先根序遍历：按根节点、左子树、右子树的顺序遍历。
• 中根序遍历：按左子树、根节点、右子树的顺序遍历。
• 后根序遍历：按左子树、右子树、根节点的顺序遍历。

二叉树是是个递归结构，它的子树仍然可看做一个二叉树，因此二叉树许多方法都可以用递归方式实现。

二叉树的三种遍历方式（Python）

参考链接：https://blog.csdn.net/weixin_41503009/article/details/82356000

# 节点类
class Node:
    def __init__(self, value=None, left=None, right=None):
        self.value = value
        self.left = left  # 左子树
        self.right = right  # 右子树

def preTraverse(root):
# 前序遍历
    if root == None:
        return
    print(root.value)
    preTraverse(root.left)
    preTraverse(root.right)

def midTraverse(root):
# 中序遍历
    if root == None:
        return
    midTraverse(root.left)
    print(root.value)
    midTraverse(root.right)

def afterTraverse(root):
# 后序遍历
    if root == None:
        return
    afterTraverse(root.left)
    afterTraverse(root.right)
    print(root.value)

if __name__ == '__main__':
    root = Node('D', Node('B', Node('A'), Node('C')), Node('E', right=Node('G', Node('F'))))
    print('前序遍历：')
    preTraverse(root)
    print('\n')
    print('中序遍历：')
    midTraverse(root)
    print('\n')
    print('后序遍历：')
    afterTraverse(root)
    print('\n')

输出如下：

前序遍历：
D
B
A
C
E
G
F

中序遍历：
A
B
C
D
E
F
G

后序遍历：
A
C
B
F
G
E
D

广度优先遍历

参考链接：https://www.cnblogs.com/kadycui/p/10184110.html

# 节点类
class Node:
    def __init__(self, value=None, left=None, right=None):
        self.value = value
        self.left = left  # 左子树
        self.right = right  # 右子树

# 广度优先遍历（按层遍历）
def levelOrder(root):
    # 如果根节点为空，则返回空列表
    if root is None:
        return res
    # 模拟一个队列储存节点
    q = []
    # 首先将根节点入队
    q.append(root)
    # 列表为空时，循环终止
    while len(q) != 0:
        length = len(q)
        for i in range(length):
            # 将同层节点依次出队
            r = q.pop(0)
            if r.left is not None:
                # 非空左孩子入队
                q.append(r.left)
            if r.right is not None:
                # 非空右孩子入队
                q.append(r.right)
            print(r.value)

# 实例化一个树节点
node1 = Node("A",
             Node("B",
                  Node("D"),
                  Node("E")
                  ),
             Node("C",
                  Node("F"),
                  Node("G")
                  )
             )
if __name__ == "__main__":
    levelOrder(node1)

输出:

A
B
C
D
E
F
G

输出所有链路

参考链接：https://segmentfault.com/q/1010000009355715

import copy
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None

def dfs(node, result, tmp=list()):
    if node is None:
        return

    tmp.append(node)
    # 这里需要用拷贝而不是用 = 赋值，也可以遍历赋值
    tmp1 = copy.deepcopy(tmp)

    if node.left is None and node.right is None:
        result.append([i.val for i in tmp])
        return

    if node.left is not None:
        dfs(node.left, result, tmp)
    # 遍历右子树需要带上不同的变量，否则左子树的tmp和右子树的tmp都指向一块内存
    if node.right is not None:
        dfs(node.right, result, tmp1)


if __name__ == '__main__':
    node1 = TreeNode('a')
    node2 = TreeNode('b')
    node3 = TreeNode('c')
    node4 = TreeNode('d')
    node5 = TreeNode('e')
    node6 = TreeNode('f')
    node7 = TreeNode('g')

    node1.left = node2
    node1.right = node3
    node2.left = node4
    node2.right = node5
    node3.left = node6
    node3.right = node7

    r = []
    dfs(node1, result=r)
    print(r)

输出：

[[‘a’, ‘b’, ‘d’], [‘a’, ‘b’, ‘e’], [‘a’, ‘c’, ‘f’], [‘a’, ‘c’, ‘g’]]

计算最大链路和

if __name__ == '__main__':
	# 以下是本题目计算最大链路和
    node1 = TreeNode(4)
    node2 = TreeNode(2)
    node3 = TreeNode(7)
    node4 = TreeNode(9)
    node5 = TreeNode(2)
    node6 = TreeNode(3)
    node7 = TreeNode(1)

    node1.left = node2
    node1.right = node3
    node2.left = node4
    node2.right = node5
    node3.left = node6
    node3.right = node7
    
    max = 0
    for i in range (len(r)):
        s = 0
        for j in r[i]:
            s += j
        if s > max:
            max = s
    print(max)

输出：

15