用二叉树同一层级所有节点的总和替换每个节点

当你遇到一颗二叉树的时候，你可以替换每个节点的值，让它们变成同一层级的所有节点值的总和。

例如，如果二叉树如下：

         10
        /  \
       2    3
      / \    \
     8   4    5

你可以用下面的二叉树替换它：

         32
        /   \
      14     11
      / \       \
    8   4       5

因为第一层级的总和是10，第二层级的总和是2+3=5，第三层级的总和是8+4+5=17。

以下是用Python实现的代码示例：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def get_level_sum(node: TreeNode, level: int) -> int:
    if not node:
        return 0
    if level == 1:
        return node.val
    left_sum = get_level_sum(node.left, level-1)
    right_sum = get_level_sum(node.right, level-1)
    return left_sum + right_sum
    
def get_tree_height(node: TreeNode) -> int:
    if not node:
        return 0
    left_height = get_tree_height(node.left)
    right_height = get_tree_height(node.right)
    return max(left_height, right_height) + 1
    
def replace_node_val(node: TreeNode):
    if not node:
        return
    height = get_tree_height(node)
    for level in range(1, height+1):
        level_sum = get_level_sum(node, level)
        replace_node_val_in_level(node, level, level_sum)
        
def replace_node_val_in_level(node: TreeNode, level: int, level_sum: int):
    if not node:
        return
    if level == 1:
        node.val = level_sum
        return
    replace_node_val_in_level(node.left, level-1, level_sum)
    replace_node_val_in_level(node.right, level-1, level_sum)

下一步，我们可以通过下面的方式创建一个二叉树：

           10
          /   \
         2     3
        / \     \
       8   4     5

root = TreeNode(10)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(8)
root.left.right = TreeNode(4)
root.right.right = TreeNode(5)

然后我们可以执行下面的代码，将二叉树所有节点的值都替换成同一层级的总和：

replace_node_val(root)

这将会使得二叉树变成下面的样子：

           32
          /   \
         14    11
        / \     \
       8   4     5

这个算法的时间复杂度是O(n^2)，其中n是节点数量。如果您想要更高效的算法，可以使用层次遍历的方式来遍历二叉树，并求出每层级的总和。这将会使得时间复杂度降至O(n)。