Subtree with Maximum Average Lintcode

最新推荐文章于 2020-12-26 18:31:32 发布

转载最新推荐文章于 2020-12-26 18:31:32 发布 · 92 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/aprilyang/p/6362024.html

本文介绍了一种算法，用于在一棵二叉树中找到平均值最大的子树，并返回该子树的根节点。通过递归遍历树的每个节点并计算其子树的平均值来实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a binary tree, find the subtree with maximum average. Return the root of the subtree.

Notice

LintCode will print the subtree which root is your return node.
It's guaranteed that there is only one subtree with maximum average.

Have you met this question in a real interview?

Yes

Example

Given a binary tree:

     1
   /   \
 -5     11
 / \   /  \
1   2 4    -2

return the node 11.

这道题是easy，在我看来不那么easy。。。

又写了个类才解决，而且代码感觉写的很差。。。

lass Result {
    public int sum;
    public int num;
    public double average;
    TreeNode node;
    public Result(int sum, int num, double average, TreeNode node) {
        this.sum = sum;
        this.num = num;
        this.average = average;
        this.node = node;
    }
}

public class Solution {
    /**
     * @param root the root of binary tree
     * @return the root of the maximum average of subtree
     */
    public TreeNode findSubtree2(TreeNode root) {
        Result rs = helper(root);
        return rs.node;
    }
    public Result helper(TreeNode root) {
        if (root == null) {
            return new Result(0, 0, Integer.MIN_VALUE, null);
        }
        Result left = helper(root.left);
        Result right = helper(root.right);
        Result rs = new Result(0, 0, Integer.MIN_VALUE, root);
        int sum = left.sum + right.sum + root.val;
        int num = left.num + right.num + 1;
        
        double average = (double) sum / (double) num;

        if (right.average > left.average) {
            rs.sum = sum;
            rs.num = num;
            rs.average = right.average;
            rs.node = right.node;
        } else {
            rs.sum = sum;
            rs.num = num;
            rs.average = left.average;
            rs.node = left.node;
        }

        if (average > rs.average) {
            rs.sum = sum;
            rs.num = num;
            rs.average = average;
            rs.node = root;
        }

        return rs;
    }
}

还可以改良一下用两个全局变量。。。代码可能好点吧

class Result {
    public int sum;
    public int num;
    public Result(int sum, int num) {
        this.sum = sum;
        this.num = num;
        // this.average = average;
        // this.node = node;
    }
}


public class Solution {
    /**
     * @param root the root of binary tree
     * @return the root of the maximum average of subtree
     */
    private TreeNode subTree = null;
    private double average = Integer.MIN_VALUE;
    
    public TreeNode findSubtree2(TreeNode root) {
        Result rs = helper(root);
        return subTree;
    }
    public Result helper(TreeNode root) {
        if (root == null) {
            return new Result(0, 0);
        }
        Result left = helper(root.left);
        Result right = helper(root.right);
        
        int sum = left.sum + right.sum + root.val;
        int num = left.num + right.num + 1;
        Result rs = new Result(sum, num);
        
        double aver = (double) sum / (double) num;

        if (aver > average) {
            average = aver;
            subTree = root;
        }

        return rs;
    }
}

反正这个题也是醉了，还是回顾一下吧。

转载于:https://www.cnblogs.com/aprilyang/p/6362024.html