初次拿到這道題，也是一點思路沒有，但是根據之前求最深的函式就可以得知了

	public static boolean isBalanced(TreeNode root) {
			if(root == null){
				return true;
			}else {
				Queue<TreeNode> mid = new LinkedList<>();
				
				mid.offer(root);
				while(!mid.isEmpty()){
					root = mid.poll();
					int left = 0;
					int right = 0;
					if(root.left != null){
						left = maxDepth2(root.left);
						mid.offer(root.left);
					}
					if(root.right != null){
						right = maxDepth2(root.right);
						mid.offer(root.right);
					}
					int i = Math.max(left, right);
					int j = Math.min(left, right);
					System.out.println("i的值    "+i);
					System.out.println("j的值    "+j);

					if(i - j> 1){
						return false;
					}
				}
				return true;
			}
    	}
 

看一下排名比較高的程式碼，有點懵逼

class Solution {
    public boolean isBalanced(TreeNode root) {
        if(height(root)>-1){
            return true;
        } else {
            return false;
        }
    }
    public boolean bb(int h_lf,int h_ri)
    {
        return h_lf-h_ri>0?h_lf-h_ri<=1:h_ri-h_lf<=1;
    }
    public int height(TreeNode t) {
        if(t == null) {
            return 0;
        }
        int left = height(t.left);
        if(left == -1) {
            return -1;
        }
        int right = height(t.right);
        if(right == -1) {
            return -1;
        }
        
        if(!bb(left,right)){
            return -1;
        }
        return max(left,right)+1;
    }
    
    public int max(int a,int b){
        return a>b?a:b;
    }
}
 

再看一個排名較高的程式碼：充分使用遞迴來解這道題目，首先看到的是先判斷根節點左右兩個的深度，之後用遞迴來分別對左右兩個進行遞迴返回，使用的同樣是取出深度進行比較，但是這裡沒有使用將每個節點都取出來儲存，而是直接使用遞迴來進行判斷讀取

 public boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        int leftL=getHeight(root.left);
        int rightL=getHeight(root.right);
        if(Math.abs(leftL-rightL)<=1){
            return isBalanced(root.left)&&isBalanced(root.right);
        }
        return false;
    }
    public int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }
        int leftL=getHeight(root.left);
        int rightL=getHeight(root.right);
        return leftL>rightL?leftL+1:rightL+1;
    }