Cracking coding interview(4.1)二叉树平衡问题

4.1 Implement a function to check if a tree is balanced. For the purposes of this question, 

a balanced tree is defined to be a tree such that no two leaf nodes differ in distance from

the root by more than one.

1.平衡二叉树定义：

平衡二叉树是:<一棵空树> || <每个节点的左右子树高度差不大于1的非空树>。

2.题目定义:任何2个叶节点节点高度差(从根节点到叶子节点)不大于1，这2个定义不等价

以下四种方法均是按照题目定义编写

对下图中单支双支或其组合二叉树：各方法判断结果不同。

(1).recur(2).bfs(3)dfs 返回结果为true, (4)isBalance 返回值为false

按题目意图而言，以下2棵树确实满足:没有任何2个叶节点的深度大于1的条件

3.前3种方法，分别应用递归，广度优先遍历，深度优先遍历对每个节点check是否满足条件的处理。

而最后一种方法，对下面的2个二叉树判断为false，这与题意是相反的。

   

import java.util.Queue;
import java.util.LinkedList;//used by bfs
import java.util.Stack;//used by dfs

class TreeNode{
	int val;
	TreeNode left;
	TreeNode right;
	public TreeNode(int val){
		this.val = val;
		this.left = null;
		this.right = null;
	}
}

public class Solution{
	//Method 1: recursive with InorderTravesal
	private static int Maxdepth = -1, Mindepth = -1;
	public static boolean recur(TreeNode root){
		Mindepth = Maxdepth = -1;
		return recurInorder(root, 0);
	}
	private static boolean recurInorder(TreeNode tNode, int layer){
		if(tNode == null)
			return true;
		else{
			layer++;
			//tNode is leaf node
			if(tNode.left == null && tNode.right == null){
				if(Maxdepth < 0){
					Maxdepth = layer;
					return true;
				}else if(Mindepth < 0){
					if(layer == Maxdepth)
						return true;
					else if(layer == Maxdepth+1 || layer == Maxdepth-1){
						Mindepth = layer;
						return true;
					}else
						return false;
				}
				if(Maxdepth != layer && Mindepth != layer)
					return false;
				else
					return true;
			}else{
				//because && so ,if find one leaf node dissatified,
				//recurInorder after && will be stopped
				return recurInorder(tNode.left, layer) && 
					recurInorder(tNode.right, layer);
			}
		}
	}
	//Method 2:bfs, 节点出队时访问
	public static boolean bfs(TreeNode root){
		if(root == null)
			return true;
		int Maxdepth = -1, Mindepth = -1, layer = 0;
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		Queue<Integer> floor = new LinkedList<Integer>();//floor synonym of layer
		queue.offer(root);
		floor.offer(1);// floor keep synchronization with queue
		TreeNode tNode = null;
		while(!queue.isEmpty()){
			tNode = queue.poll();
			layer = floor.poll();
			if(tNode.left == null && tNode.right == null){	
				if(Maxdepth == -1){
					Maxdepth = layer;
				}else if(Mindepth == -1){
					if(layer+1 == Maxdepth || layer-1 == Maxdepth){
						Mindepth = layer;
					}else if(layer != Maxdepth)
						return false;
				}
				if(Maxdepth != layer && Mindepth != layer)
					return false;
			}else{
				if(tNode.left != null){
					queue.offer(tNode.left);
					floor.offer(layer+1);
				}
				if(tNode.right != null){
					queue.offer(tNode.right);
					floor.offer(layer+1);
				}
			}
		}
		return true;
	}	
	//Method3:dfs 节点入队时访问 same as pre-order traversal
	public static boolean dfs(TreeNode root){
		if(root == null)
			return true;
		Stack<TreeNode> s = new Stack<TreeNode>();
		Stack<Integer> floor = new Stack<Integer>();
		TreeNode tNode = root;
		int Maxdepth = -1, Mindepth = -1, layer = 1;
		while(!s.empty() || tNode != null){
			while(tNode != null){
				//node tNode is leaf node
				if(tNode.left == null && tNode.right == null){
					if(Maxdepth == -1)
						Maxdepth = layer;
					else if(Mindepth == -1){
						if(Maxdepth == layer+1 || Maxdepth == layer-1)
							Mindepth = layer;
						else if(Maxdepth != layer)
							return false;
					}
					if(Maxdepth != layer && Mindepth != layer)
						return false;
					tNode = null;//the way break loop 
				}else{
					s.push(tNode);
					floor.push(layer);
					tNode = tNode.left;
					layer++;
				}
			}
			if(!s.empty()){
				tNode = s.pop();
				tNode = tNode.right;
				layer = floor.pop()+1;
			}
		}		
		return true;
	}
	//Method4:(maxDepth - MinDepth == 0)
	public static boolean isBalance(TreeNode root){
//		System.out.println(maxDepth(root) + " " + minDepth(root));
		return maxDepth(root)-minDepth(root) <= 1;
	}
	private static int minDepth(TreeNode tNode){
		if(tNode == null)
			return 0;
		else
			return 1 + Math.min(minDepth(tNode.left), minDepth(tNode.right));
	}
	public static int maxDepth(TreeNode tNode){
		if(tNode == null)
			return 0;
		else
			return 1 + Math.max(maxDepth(tNode.left), maxDepth(tNode.right));			
	}
	public static void main(String[] args){
	/**/
		//test for recur
		System.out.println("R1:"+Solution.recur(null));
		TreeNode root = new TreeNode(0);
		System.out.println("R2:"+Solution.recur(root));
		root.left = new TreeNode(1);
		System.out.println("R3:"+Solution.recur(root));
		root.left.left = new TreeNode(2);
		System.out.println("R4:"+Solution.recur(root));
		root.right = new TreeNode(3);
		root.right.right = new TreeNode(4);
		root.right.right.right = new TreeNode(5);
		root.right.right.right.right = new TreeNode(6);
		System.out.println("R5:"+Solution.recur(root));	
	/**/
	/**/
		//test for bfs root
		System.out.println("R1:"+Solution.bfs(null));
		TreeNode root2 = new TreeNode(0);
		System.out.println("R2:"+Solution.bfs(root2));
		root2.left = new TreeNode(1);
		System.out.println("R3:"+Solution.bfs(root2));
		root2.left.left = new TreeNode(2);
		System.out.println("R4:"+Solution.bfs(root2));
		root2.right = new TreeNode(3);
		root2.right.right = new TreeNode(4);
		root2.right.right.right = new TreeNode(5);
		root2.right.right.right.right = new TreeNode(6);
		System.out.println("R5:"+Solution.bfs(root2));	
	/**/
	/**/
		//test for dfs
		System.out.println("R1:"+Solution.dfs(null));
		TreeNode root3 = new TreeNode(0);
		System.out.println("R2:"+Solution.dfs(root3));
		root3.left = new TreeNode(1);
		System.out.println("R3:"+Solution.dfs(root3));
		root3.left.left = new TreeNode(2);
		System.out.println("R4:"+Solution.dfs(root3));
		root3.right = new TreeNode(3);
		root3.right.right = new TreeNode(4);
		root3.right.right.right = new TreeNode(5);
		root3.right.right.right.right = new TreeNode(6);
		System.out.println("R5:"+Solution.dfs(root3));	
	/**/
	/**/
		//test for isBalance
		System.out.println("R1:"+Solution.isBalance(null));
		TreeNode root4 = new TreeNode(0);
		System.out.println("R2:"+Solution.isBalance(root4));
		root4.left = new TreeNode(1);
		System.out.println("R3:"+Solution.isBalance(root4));
		root4.left.left = new TreeNode(2);
		System.out.println("R4:"+Solution.isBalance(root4));
		root4.right = new TreeNode(3);
		root4.right.right = new TreeNode(4);
		root4.right.right.right = new TreeNode(5);
		root4.right.right.right.right = new TreeNode(6);
		System.out.println("R5:"+Solution.isBalance(root4));	
	/**/
		TreeNode test = new TreeNode(0);
		test.left = new TreeNode(1);
		test.left.left = new TreeNode(3);
		test.left.left.right = new TreeNode(5);
		test.right = new TreeNode(2);
		test.right.right = new TreeNode(4);
		test.right.right.right = new TreeNode(6);
		System.out.println("T1[isBalance]="+isBalance(test));
		System.out.println("T2[bfs]="+Solution.bfs(test));
		System.out.println("T2[dfs]="+Solution.dfs(test));
		System.out.println("T2[recur]="+Solution.recur(test));
	}
}