判断二叉树是不是平衡

import java.util.*;


public class BalancedBTree {
	/** 
     * Q判断二叉树是不是平衡 
        1 
       / \ 
      2   3 
     / \   \ 
    4   5   6 
       / 
      7 
     */  
    public static void main(String[] args) {  
  
        int[][] threeBTrees={  
                {1,2,3,4,5,0,6,0,0,7},//balanced  
                {1,2,3,4,5,0,0,0,0,7},//not balanced  
                };  
        for(int[] each:threeBTrees){  
            Node node=createTree(each);  
            AuxClass aux= new AuxClass();  
            boolean result=isBalanced(node,aux);  
            System.out.println(result);  
        }  
    }  
  
    /* 
     * 如果我们用后序遍历的方式遍历二叉树的每一个结点，在遍历到一个结点之前我们已经遍历了它的左右子树。 
     * 只要在遍历每个结点的时候记录它的深度（某一结点的深度等于它到叶节点的路径的长度）， 
     * 我们就可以一边遍历一边判断每个结点是不是平衡的 
     * C/C++代码可参见 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 
     * 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass 
     */  
    public static boolean isBalanced(Node node,AuxClass aux){  
        if(node==null){  
            aux.depth=0;  
            return true;  
        }  
        AuxClass left=new AuxClass();  
        AuxClass right=new AuxClass();  
        //get leftTreeDepth and rightTreeDepth of a node.If the 'diff' is bigger than 1,return false;true otherwise  
        if(isBalanced(node.getLeft(),left)&&isBalanced(node.getRight(),right)){  
            int leftDepth=left.depth;  
            int rightDepth=right.depth;  
            int diff=leftDepth-rightDepth;  
            if(diff==1||diff==-1||diff==0){  
                aux.depth=leftDepth>rightDepth?leftDepth+1:rightDepth+1;  
                return true;  
            }  
        }  
        return false;  
    }  
    public static class AuxClass{  
        private int depth;  
    }  
    public static Node createTree(int[] data){    
        List<Node> nodeList=new ArrayList<Node>();    
        for(int each:data){    
            Node n=new Node(each);    
            nodeList.add(n);    
        }    
        int lastRootIndex=data.length/2-1;    
        for(int i=0;i<=lastRootIndex;i++){    
            Node root=nodeList.get(i);    
            Node left=nodeList.get(i*2+1);    
            if(left.getData()!=0){    
                root.setLeft(left);    
            }else{    
                root.setLeft(null);    
            }    
            if(i*2+2<data.length){    
                Node right=nodeList.get(i*2+2);    
                if(right.getData()!=0){    
                    root.setRight(right);    
                }else{    
                    root.setRight(null);    
                }    
            }    
                
        }    
        Node root=nodeList.get(0);    
        return root;    
    }    
    private static  class Node{    
        private int data;    
        private Node left;    
        private Node right;    
        private int maxLeftLen;//the max length of leftTree    
        private int maxRightLen;        
        public Node(int i){    
            data=i;    
        }    
        public int getData() {    
            return data;    
        }    
        public void setData(int data) {    
            this.data = data;    
            this.left=null;    
            this.right=null;    
        }    
        public Node getLeft() {    
            return left;    
        }    
        public void setLeft(Node left) {    
            this.left = left;    
        }    
        public Node getRight() {    
            return right;    
        }    
        public void setRight(Node right) {    
            this.right = right;    
        }    
        public int getMaxLeftLen() {    
            return maxLeftLen;    
        }    
        public void setMaxLeftLen(int maxLeftLen) {    
            this.maxLeftLen = maxLeftLen;    
        }    
        public int getMaxRightLen() {    
            return maxRightLen;    
        }    
        public void setMaxRightLen(int maxRightLen) {    
            this.maxRightLen = maxRightLen;    
        }    
    }    
}