题目链接：

https://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?tpId=13&tqId=11192&tPage=2&rp=2&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking

题目描述：

解题思路：

（1）递归解法，需要重复遍历结点多次的解法。

已经AC的代码：

public class isBalancedTree {
	
	class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;
		
		public TreeNode(int data) {
			this.val = data;
		}
	}
	
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root == null)
        	return true;
        int lf_high = tree_high(root.left);
        int rg_high = tree_high(root.right);
        int balance = lf_high - rg_high;
        if(balance == 1 || balance == -1 || balance == 0) {
        	return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
        }else {
        	return false;
        }
    }
    
    public int tree_high(TreeNode root) {
    	if(root == null) {
    		return 0;
    	}
        int lf_high = tree_high(root.left);
        int rg_high = tree_high(root.right);
        if(lf_high > rg_high) {
        	return lf_high + 1;
        }else {
			return rg_high + 1;
		}
    	
    }

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 构建树
		//        1
		//       / \
		//      2   3
		//     / \   \
		//    4   5   6
		//       /
		//       7		           
		isBalancedTree balancedTree  = new isBalancedTree();
		TreeNode node_1 = balancedTree.new TreeNode(1);
		TreeNode node_2 = balancedTree.new TreeNode(2);
		TreeNode node_3 = balancedTree.new TreeNode(3);
		TreeNode node_4 = balancedTree.new TreeNode(4);
		TreeNode node_5 = balancedTree.new TreeNode(5);
		TreeNode node_6 = balancedTree.new TreeNode(6);
		TreeNode node_7 = balancedTree.new TreeNode(7);
		node_1.left = node_2;
		node_1.right = node_3;
		node_2.left = node_4;
		node_2.right = node_5;
		node_3.right = node_6;
		node_5.left = node_7;
		System.out.println(balancedTree.IsBalanced_Solution(node_1));
	}

}

上面的代码固然简洁，但是我们也要注意到由于一个结点会被重复遍历多次，这种思路的时间效率不高。例如在函数IsBalanced_Solution中输入上面代码中的二叉树，我们将首先判断根结点（结点1）是不是平衡的。此时我们往函数tree_high输入左子树的根结点（结点2）时，需要遍历结点4、5、7。接下来判断以结点2为根结点的子树是不是平衡二叉树的时候，仍然需要遍历结点4、5、7。毫无疑问，重复遍历同一个结点会影响性能。接下来我们寻找不需要重复遍历的算法。

（2）每个节点只需要遍历一次的解法：

如果我们用后序遍历的方式遍历二叉树的每一个结点，在遍历到一个结点之前我们就已经遍历了它的左右子树。只要在遍历每个节点的时候记录它的深度，我们就可以一边遍历一边判断每个节点是不是平衡的。

public class isBalancedTree {
	
	class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;
		
		public TreeNode(int data) {
			this.val = data;
		}
	}
	
	/**
	 * 树的后序遍历递归实现
	 * @param root
	 */
	public void postOrder(TreeNode root) {
		if(root != null) {
			postOrder(root.left);
			postOrder(root.right);
			System.out.println(root.val);
		}
	}
	
	public boolean IsBalanced_Solution(TreeNode root) {
		int[] depth = new int[] {0};
		return isBalanced(root, depth);
	}
	
	public boolean isBalanced(TreeNode root, int[] depth) {
		if(root == null) {
			depth[0] = 0;
			return true;
		}
		int[] left = new int[] {0};
		int[] right = new int[] {0};
		if(isBalanced(root.left, left) && isBalanced(root.right, right)) {
			int diff = left[0] - right[0];
			if(diff <= 1 && diff >= -1) {
				depth[0] = 1 +(left[0] > right[0] ? left[0] : right[0]);
				return true;
			}
		}
		return false;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 构建树
		//        1
		//       / \
		//      2   3
		//     / \   \
		//    4   5   6
		//       /
		//       7		           
		isBalancedTree balancedTree  = new isBalancedTree();
		TreeNode node_1 = balancedTree.new TreeNode(1);
		TreeNode node_2 = balancedTree.new TreeNode(2);
		TreeNode node_3 = balancedTree.new TreeNode(3);
		TreeNode node_4 = balancedTree.new TreeNode(4);
		TreeNode node_5 = balancedTree.new TreeNode(5);
		TreeNode node_6 = balancedTree.new TreeNode(6);
		TreeNode node_7 = balancedTree.new TreeNode(7);
		node_1.left = node_2;
		node_1.right = node_3;
		node_2.left = node_4;
		node_2.right = node_5;
		node_3.right = node_6;
		node_5.left = node_7;
//		balancedTree.postOrder(node_1);
		System.out.println(balancedTree.IsBalanced_Solution(node_1));
	}

}