题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。
剑指Offer 书上的题意：判断左右子树的深度是否超过1，不超过就是一颗平衡二叉树

概念：Self-Balancing Binary Search Tree；要么是一颗空树，要么是左子树和右子树都是平衡二叉树，且左右子树深度之差 绝对值不超过1.那么二叉树上节点的左子树减去右子树深度的值为平衡因子 BF，BF只能为-1,0,1.

那么判断二叉树不平衡，只要有一个节点的平衡因子绝对值大于1，就是不平衡的。由名字可知 这个平衡二叉树的前提是一颗二叉搜索树。。

但是这道题不需要判断二叉搜索树；

public class 平衡二叉树 {
	
	public static class TreeNode {
	    int val = 0;
	    TreeNode left = null;
	    TreeNode right = null;
	    public TreeNode(int val) {
	        this.val = val;
	    }
	}
	
	/*作为引用传递val的值*/
	static class Num{
		int val = 0;
		public Num (int val) {
			this.val = val;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeNode root1 = new TreeNode(1);
		TreeNode root2 = new TreeNode(2);
		TreeNode root3 = new TreeNode(3);
		TreeNode root4 = new TreeNode(4);
		TreeNode root5 = new TreeNode(5);
		TreeNode root6 = new TreeNode(6);
//		TreeNode root7 = new TreeNode(7);
		root1.left = root2;
		root1.right = root3;
		root2.left = root4;
		root2.right = root5;
		root5.left = root6;
//		root3.right = root7;
		System.out.println(IsBalanced_Solution2(root1));
	}
	
	public static boolean IsBalanced_Solution2(TreeNode root) {
		if (root==null) {
			return true;
		}
		Num num = new Num(0);
		return IsBalanced(root, num);
	}
	
	/*
	 * 方法1
	 * 递归的思想：传入一个节点，返回该节点是否平衡，和该节点的深度；
	 *方法体里应该是判断该节点的左右节点的深度之差不大于1，和计算节点深度，节点深度等于左右子节点最大的深度+1；
	 *递归的出口是：1.节点为空，那么该节点是平衡的；
	 *		    2.该节点不为空，就计算左右节点的深度，并判断平衡因子是否小于1，而且返回左右子树深度最大的+1。*/
	public static boolean IsBalanced(TreeNode root,Num num) {
		if (root==null) {
			num.val = 0;
			return true;
		}
		
		Num leftlen = new Num(0); 
		Num rightlen = new Num(0); //引用传递
		boolean left = IsBalanced(root.left, leftlen);//得到左节点的深度
		boolean right = IsBalanced(root.right, rightlen);//得到右节点的深度
		if (left&&right) {
			if (leftlen.val-rightlen.val>=-1&&leftlen.val-rightlen.val<=1) {
				num.val = Math.max(leftlen.val, rightlen.val)+1;//返回该节点的深度
				return true;
			}
		}
		return false;
	}
	
	
	/*
	 * 方法2
	 * 虽然重复计算了节点，但是递归的思路还是要学习的~~~~~~*/
    public boolean IsBalanced_Solution(TreeNode root) {
    	if (root==null) {
			return true;
		}
    	int left = TreeDepth(root.left);
    	int right = TreeDepth(root.right);
    	int diff = left-right;
    	if (diff>1||diff<-1) {
			return false;
		}
		return IsBalanced_Solution(root.left)&&IsBalanced_Solution(root.right);
    }

	public int TreeDepth(TreeNode root) {
		// TODO Auto-generated method stub
    	if (root==null) {
			return 0;
		}
    	int leftnum = TreeDepth(root.left);
    	int rightnum = TreeDepth(root.right);
		return Math.max(leftnum+1, rightnum+1);
	}
}