Question：

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

Return true.

Example 2:

Given the following tree [1,2,2,3,3,null,null,4,4]:

       1
      /      2   2
    /    3   3
  /  4   4

Return false.

定義：

平衡二叉樹（AVL）：1、空二叉樹是AVL樹；
2、如果T是一顆非空的二叉搜索樹，TL和TR分別是其左子樹和右子樹，那麽當T滿足一下條件時，T是一顆AVL樹：

　　　　　　　　　　　　（1）TL和TR是AVL樹；

　　　　　　　　　　　　（2）|HL-HR|<=1，HL和HR分別是左子樹和右子樹的高度

算法思路：采用遞歸的思想，從root節點進行遞歸的調用。分別計算各個節點的左右子樹的高度；若高度差大於1或者計算的高度不合法（即高度小於零））則返回-1（表示不是平衡樹），否則返回子樹的最大高度加一。

package easy;

import dataStructure.TreeNode;

public class L110BalancedBinaryTree {
    public boolean isBalanced(TreeNode root) {
        if(root==null) return true;
        int depth=calHeight(root);
        
 
return depth>=0;
    }

    private int calHeight(TreeNode root) {
        // TODO Auto-generated method stub
        if(root==null){
            return 0;
        }
        int left=0;int right=0;
        if(root.left!=null){
            left=calHeight(root.left);
        }
        if(left==-1)return -1;
        if(root.right!=null){
            right=calHeight(root.right);
        }
        if(right==-1) return -1;
        if(Math.abs(left-right)>1 ||left<0 ||right<0){
            return -1;
        }else{
            return Math.max(left,right)+1;
        }
    }


    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        TreeNode node1 = new TreeNode(4);
        TreeNode node2 = new TreeNode(8);
        TreeNode node3 = new TreeNode(11);
        TreeNode node4 = new TreeNode(13);
        TreeNode node5 = new TreeNode(4);
        TreeNode node6 = new TreeNode(7);
        TreeNode node7 = new TreeNode(2);
        TreeNode node8 = new TreeNode(1);
        root.left = node1;
        root.right = node2;
        node1.left = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;
        node5.right = node8;

        node1.right = null;
        node6.left = null;
        node6.right = null;
        node7.left = null;
        node7.right = null;
        node4.left = null;
        node4.right = null;
        node5.left = null;
        node8.left = null;
        node8.right = null;
        L110BalancedBinaryTree l110 = new L110BalancedBinaryTree();
        boolean isBanlace = l110.isBalanced(root);
        System.out.println(isBanlace);
        System.out.println("~~~~~~~~~~~~~~");
        TreeNode n1=new TreeNode(1);
        TreeNode n2=new TreeNode(2);
        TreeNode n3= new TreeNode(3);
        n1.left=null;
        n1.right=n2;
        n2.left=null;
        n2.right=n3;
        n3.left=null;
        n3.right=null;
        System.out.println(l110.isBalanced(n1));
    }
}

【Leetcode】110. Balanced Binary Tree