随笔 - 1637  文章 - 0  评论 - 740  0

给一棵二叉树,找到有最大平均值的子树。返回子树的根结点。

Example

样例1

输入:
{1,-5,11,1,2,4,-2}
输出:11
说明:
这棵树如下所示:
     1
   /   \
 -5     11
 / \   /  \
1   2 4    -2 
11子树的平均值是4.333,为最大的。

样例2

输入:
{1,-5,11}
输出:11
说明:
     1
   /   \
 -5     11
1,-5,11 三棵子树的平均值分别是 2.333,-5,11。因此11才是最大的.
参考代码:
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the root of binary tree
    @return: the root of the maximum average of subtree
    """
    def findSubtree2(self, root):
        # write your code here
        self._result_node = None
        self._result_val = -float("inf")
        self.find_sub_tree(root)
        return self._result_node
    
    
    def find_sub_tree(self, root):
        if not root:
            return 0, 0
        
        left_sum, left_size = self.find_sub_tree(root.left)
        right_sum, right_size = self.find_sub_tree(root.right)
        
        sum = root.val + left_sum + right_sum
        size = left_size + right_size + 1
        avg_val = float(sum)/size
        
        if self._result_node is None or self._result_val < avg_val:
            self._result_node = root
            self._result_val = avg_val
            
        return sum, size

 

关于何时使用成员变量的问题,如果_result_node 不是成员变量,则需要以参数形式返回,在所有节点遍历时候用到,导致代码重复,因此直接使用成员变量(有点全局的味道)更好。

 

官方代码:【写得比我好,尤其是成员变量使用static】

class Solution:
    # @param {TreeNode} root the root of binary tree
    # @return {TreeNode} the root of the maximum average of subtree
    average, node = 0, None

    def findSubtree2(self, root):
        # Write your code here
        self.helper(root)
        return self.node

    def helper(self, root):
        if root is None:
            return 0, 0

        left_sum, left_size = self.helper(root.left)
        right_sum, right_size = self.helper(root.right)

        sum, size = left_sum + right_sum + root.val, \
                    left_size + right_size + 1

        if self.node is None or sum * 1.0 / size > self.average:
            self.node = root
            self.average = sum * 1.0 / size

        return sum, size

  

需要在遍历中记住上次遍历节点,根据上次的节点和当前节点进行比较而得到result的算法模板:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution():
   last_node = None
   result = None
    
   def run(self, root):
        self.dfs(root)
        return self.result
    
   def dfs(self):
       if last_node is None:
           last_node = root
       else:
           do_sth(last_node, root)
            
       dfs(root.left)
 
       dfs(root.right)

  

posted on 2019-09-29 20:43 bonelee 阅读(...) 评论(...) 编辑 收藏