Leetcode 110 Balanced Binary Tree 是不是平衡二叉树

题目：

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example 1:

Given the following tree [3,9,20,null,null,15,7]:

    3
   / \
  9  20
    /  \
   15   7

解决办法：

package test;

public class LC110Try2
{
	public boolean isBalanced(TreeNode root)
	{
		if(root==null){
			return true;
		}
		int h=getPass(root);		
		return h!=-1;
	}
	
	public int getPass(TreeNode root){
		if(root==null){
			return 0;
		}
		int lefth=getPass(root.left);
		if(lefth==-1){
			return -1;
		}
		int righth=getPass(root.right);
		if(righth==-1){
			return -1;
		}
		if(Math.abs(lefth-righth)>1){
			return -1;
		}
		return Math.max(lefth, righth)+1;
	}

}

tag的解决办法：不推荐
 

package test;

public class LC110Try1
{
	public int tag = 0;

	public boolean isBalanced(TreeNode root)
	{
		if(root==null){
			return true;
		}
		getPass(root);
		
		if(Math.abs(tag)<=1){
			return true;
		}
		return false;
	}

	public int getPass(TreeNode root)
	{
			
		int deep = 0;
		int leftdeep = 0;
		int rightdeep = 0;
		if (root.left != null)
		{
			leftdeep = getPass(root.left);
			if (Math.abs(tag) > 1)
			{
				return tag;
			}
		}
		if (root.right != null)
		{
			rightdeep = getPass(root.right);
			if (Math.abs(tag) > 1)
			{
				return tag;
			}
		}		
		tag = leftdeep - rightdeep;
		if (Math.abs(tag) > 1)
		{
			return tag;
		}
		deep = Math.max(leftdeep, rightdeep)+1;
		return deep;

	}

}

 

class Solution {
    boolean ret=true;
    public boolean isBalanced(TreeNode root) {
        if(root==null){
            return ret;            
        }
        deep(root);
        return ret;

    }
    public int deep(TreeNode p){
        if(!ret){
            return -1000;
        }
        if(p==null){
            return 0;
        }
        if(p.left==null && p.right==null){
            return 1;
        }
        int ld=deep(p.left);
        int rd=deep(p.right);
        if(Math.abs(ld-rd)>1 || !ret){
            ret=false;
            return -1000;
        }
        return Math.max(ld,rd)+1;

    }
}

哈哈