剑指 Offer 55 - II. 平衡二叉树

题目

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
最初级的解法：这道题本身就是基于Offer55-I出发的，先采用层序遍历的思想，把每一层的节点都保存到queue队列中，然后把每个节点的左右子树分别传到maxDepth()函数中，求解其左右子树的最大深度，然后进行比较即可，若出现左右子树深度差大于1的情况，则直接return。这个方法复杂度实在是有点高，时间复杂度最差应该是O(N^2)，进而导致时间超时。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    boolean flag = true;
    public boolean isBalanced(TreeNode root) {
        if(root==null) { return true; }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        
        while(!queue.isEmpty()){
            for(int n =queue.size();n>0 && flag==true;n--){
                TreeNode node = queue.poll();
                if(node.left != null){ queue.add(node.left); }
                if(node.right != null){ queue.add(node.right); }
                int left = maxDepth(node.left)+1;
                int right = maxDepth(node.right)+1;
                // System.out.println("root:"+root.val+" left:"+left+" right:"+right);
                if(Math.abs(left-right)>1){
                    flag=false;
                    // System.out.println("come in "+flag);
                    // return false;
                }
            }
       
        }
         return flag;
        
    }
    public int maxDepth(TreeNode root){
        if(root == null){ return 0;}
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        // if(Math.abs(left-right)>1){
        //     flag=false;
        //     return
        // }
        return Math.max(left+1,right+1);
    }
}

受到K神大佬启发，采用剪枝思想，因为本身Offer-55 I就是从下到上走的，从底至顶返回子树深度，在每次求解maxDepth()的时候，其实在里面加一个判断就行，判断每个子树的深度差是否超过1，如果超过1则直接return。优化后的代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    boolean flag = true;
    public boolean isBalanced(TreeNode root) {
        if(root==null) { return true; }
        maxDepth(root);
        return flag;

    }
    public int maxDepth(TreeNode root){
        if(root == null || flag==false){ return 0;}
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        if(Math.abs(left-right)>1 || flag==false){
            flag=false;
            return 0;
        }
        return Math.max(left+1,right+1);
    }
}

复杂度分析

时间复杂度：O(N)，因为需要遍历N个节点。
空间复杂度：O(N)，退化成链表的时候，就需要递归到最底部，系统会开辟O(N)的占空间。