二叉树与分治法整理

597. 具有最大平均数的子树

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */


public class Solution {
    /*
     * @param root: the root of binary tree
     * @return: the root of the maximum average of subtree
     */
    class Type {
        int sum;
        int count;
        Type(int s, int c) {
            sum = s;
            count = c;
        }
    }
    TreeNode res = null;
    Type max = new Type(0, 0);
    public TreeNode findSubtree2(TreeNode root) {
        // write your code here
        helper(root);
        return res;
    }
    //1. 对于root,返回该节点为根节点的count和sum
    private Type helper(TreeNode root) {
        if (root == null) {
            return new Type(0, 0);
        }
        
        //2.拆解
        Type left = helper(root.left);
        Type right = helper(root.right);
        int sum = left.sum + right.sum + root.val;
        int count = left.count + right.count + 1; //＋１手误
        if (res == null || sum * max.count > max.sum * count) {
            max.count = count;
            max.sum = sum;
            res = root;
        }
        return new Type(sum, count);　//忘记了
    }
}

①计算ｓｕｍ时每层＋１②忘记ｈｅｌｐｅｒ返回值。

答案可以更简单一点。

if (subtree == null ||
            subtreeResult.sum * result.size < result.sum * subtreeResult.size
        ) {
            subtree = root;
            subtreeResult = result;
        }

93. 平衡二叉树

注意：分治的时候，合并处理时仔细，树的高度要+1。

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */


public class Solution {
    /*
     * @param root: The root of binary tree.
     * @return: True if this Binary tree is Balanced, or false.
     */
    class Type {
        int h;
        boolean b;
        Type(int h, boolean b) {
            this.h = h;
            this.b = b;
        }
    }
    public boolean isBalanced(TreeNode root) {
        // write your code here
        return check(root).b;
        
    }
    private Type check(TreeNode root) {
        Type res = new Type(0, true);
        if (root == null) {
            return res;
        }
        
        
        Type left = check(root.left);
        Type right = check(root.right);
        if (left.b == false || right.b == false || Math.abs(left.h - right.h) > 1) {
            res.b = false;
        }
        res.h = Math.max(left.h, right.h) + 1; //记得+1
        return res;
    }
}