判断二叉树是不是平衡二叉树

出自：http://zhedahht.blog.163.com/

平衡树：

         平衡树，即平衡二叉树，具有以下性质：它是一颗空树或者它的左右两个子树的高度差的绝对值不超过1，并且左右子树都是平衡二叉树。

          如图：

                             

          判断是不是二叉树：

          思路一：通过算出二叉树每个节点左右两棵子树的高度，然后比较高度的值

          

示例：

public class Tree {

public String node ;
public Tree leftTree ;
public Tree rightTree ;
public String getNode() {
return node;
}
public void setNode(String node) {
this.node = node;
}
public Tree getLeftTree() {
return leftTree;
}
public void setLeftTree(Tree leftTree) {
this.leftTree = leftTree;
}
public Tree getRightTree() {
return rightTree;
}
public void setRightTree(Tree rightTree) {
this.rightTree = rightTree;
}


public Tree createTree(){

Tree _root = new Tree();
_root.setNode("1");

Tree _tree2 = new Tree() ;
_tree2.setNode("2");

Tree _tree3 = new Tree();
_tree3.setNode("3");
 
Tree _tree4 = new Tree() ;
_tree4.setNode("4");

Tree _tree5 = new Tree() ;
_tree5.setNode("5");


Tree _tree6 = new Tree() ;
_tree6.setNode("6");
_tree3.setRightTree(_tree6);

Tree _tree7 = new Tree() ;
_tree7.setNode("7");
_tree5.setRightTree(_tree7);

_tree2.setLeftTree(_tree4);
_tree2.setRightTree(_tree5);

_root.setLeftTree(_tree2);
_root.setRightTree(_tree3);
return _root ;

}
}

public class DeepTree {

public static void main(String[] args) {
Tree _tree = new Tree();
Tree _tree01 = _tree.createTree() ;
// int _deep = deep(_tree01);
// System.out.println(String.valueOf(_deep));
// firstScan(_tree01);

int[] in = new int[1] ;
in[0] = 0 ;
System.out.println(isBlance(_tree01 ,in));
}

public static int deep( Tree tree ){
if( tree == null ){
return 0 ;
}

System.out.println(tree.getNode());

int left = deep(tree.getLeftTree()) ;
int right = deep(tree.getRightTree());
return (left > right) ? (left+1):(right+1) ;
}


/**
* 先序遍历
* @param tree
* @return
*/
public static void firstScan( Tree tree ){
if( tree == null ){
return ;
}

System.out.println(tree.getNode());
firstScan(tree.getLeftTree()) ;
firstScan(tree.getRightTree());
}

/**
* 中序遍历 递归
* @param tree
*/
public static void midScan( Tree tree ){
if( tree == null ){
return ;
}

midScan(tree.getLeftTree()) ;
System.out.println(tree.getNode());
midScan(tree.getRightTree());
}

/**
* 后序遍历 递归
* @param tree
*/
public static void lastScan( Tree tree ){
if( tree == null ){
return ;
}
lastScan(tree.getLeftTree()) ;
lastScan(tree.getRightTree());
System.out.println(tree.getNode());
}

/**
* 先序遍历  非递归
* @param tree
*/
public static void firstScanNoRecur( Tree tree ){

Stack<Tree> _stack = new Stack<Tree>() ;
_stack.push(tree) ;

while( !_stack.empty() ){
Tree _node = _stack.pop() ;
System.out.println(_node.getNode());
//先向栈中push右子树 然后push左子树  在访问的时候会先访问左子树
if( _node.getRightTree() != null ){
_stack.push(_node.getRightTree()) ;
}
if( _node.getLeftTree() != null ){
_stack.push(_node.getLeftTree()) ;
}
}

}

/**
* 中序遍历  非递归
* @param tree
*/
public static void midScanNoRecur( Tree tree ){

Stack<Tree> _stack = new Stack<Tree>() ;
Tree node = tree ;

while( node != null || !_stack.empty() ){
if( node != null ){
_stack.push(node) ;
node = node.getLeftTree() ;
}else{
node = _stack.pop() ;
System.out.println(node.getNode());
node = node.getRightTree();
}
}
}

/**
* 是否平衡树
* @param tree
* @return
*/
public static boolean isBlance( Tree tree ){
if( tree == null ){
return true ;
}
int left = deep(tree.getLeftTree());
int right = deep(tree.getRightTree());
int diff = left - right ;
if( diff > 1 || diff < -1 ){
return false ;
}
return isBlance(tree.getLeftTree()) && isBlance(tree.getRightTree()) ;
}

/**
* 是否平衡树(改进算法)
* @param tree
* @param a
* @return
*/
public static boolean isBlance( Tree tree , int[] a){
if( tree == null ){
a[0] = 0 ;
return true ;
}
System.out.println(tree.getNode());
boolean _flag01 = isBlance( tree.getLeftTree() , a);
int left = a[0] ;

boolean _flag02 = isBlance( tree.getRightTree() , a);
int right = a[0] ;

if( _flag01 && _flag02 ){
int diff = left - right ;
if( diff > 1 || diff < -1 ){
return false ;
}else{
a[0] = (left > right) ? (left+1):(right+1) ;
return true ;
}
}
return false ;
}




}