判读一棵树是不是平衡二叉树

要求

给定一棵二叉树，判断是否为平衡二叉树

思路

总体思路是这样的

先分别判断左右子树是不是平衡的，若左右子树都是平衡二叉树，则判断左右子树的高度差是不是满足绝对值小于等于 1 的条件

伪代码

is_balanced_tree = true;

void is_balance(root)
{
    get_height(root)
    return is_balanced_tree;
}

get_height(TreeNode root)
{
    // 计算左子树的高度
    lh = get_height(root.left);

    // 计算右子树高度
    rh = get_height(root.right);

    //判断是否是平衡树
    if(abs(lh-rh)>1){
        is_balanced_tree = false;
    }
    return max(lh,rh);
}

具体代码如下：

public class BinaryTreeTest {
    public static void main(String[] args) {
        // 构造一棵树
        TreeNode root = generateTree();

        // 判断是不是平衡树
        boolean isBalance = isBalance(root,0);
        System.out.println(isBalance);



    }

    private static boolean isBalance(TreeNode root,int level) {

        // 总体思路还是按照二叉树后序遍历的方式，先判断左子树，再判断右子树
        // 判断左子树的过程中，要找到 两个 有效信息
        // 第一：左子树的深度； 第二：左子树是否是平衡树
        // 若左子树不是平衡树，则可以判断整棵树不是平衡树，直接返回 false
        // 若左子树是平衡术，则根据返回左子树的深度，返回左子树的深度是为了
        // 当递归最后返回的时候，利用跟节点的左右子树的深度，判断整棵树是不是平衡树
        // 右子树的遍历也是同样的道理

        // 这里定义为一个元素个数的数组，是为了在递归调用时，其中某次递归调用改变了这个值，
        // 对其他所有的过程可见，相当于一个全局变量
        boolean[] res = new boolean[1];
        res[0] = true;

        // level 纪录的是，不满足平衡树的节点所在的树中的层次。
        level = getHight(root,1, res);
        System.out.println(level);
        return res[0];

    }

    private static int getHight(TreeNode root,int level, boolean[] res) {

        if (root == null) {
            return 0;
        }



        int lHeight = getHight(root.left, level+1,res);

        // 如果发现左子树已经不是平衡二叉树，则直接返回
        // 其实这个 if 语句的判断对整体程序对理解有一点对障碍，完全可以没有，
        // 这个判断对作用就在于，当法相某个左子树已经不是平衡树当时候，可以直接返回了，程序不用在继续递归调用
        // 其实完全可以没有，这样只是减少了算法计算量，但是对于整个程序的理解造成一定的困难，至少对我来说是这样。
        if (!res[0]) {
            return level;
        }

        int rHeight = getHight(root.right,level+1, res);
        if (!res[0]) {
            return rHeight;
        }


        if (Math.abs(lHeight - rHeight) > 1) {
            res[0] = false;
//            return level;
        }
        return Math.max(lHeight,rHeight)+1;
    }

    private static TreeNode<Integer> generateTree() {
        TreeNode<Integer> root = new TreeNode<>(1);
        TreeNode<Integer> second = new TreeNode<>(2);
        TreeNode<Integer> third = new TreeNode<>(3);
        TreeNode<Integer> forth = new TreeNode<>(4);
        TreeNode<Integer> fifth = new TreeNode<>(5);

        root.left = second;
        root.right = third;

        second.left = forth;
        forth.left = fifth;

        return root;
    }
}

public class TreeNode<T> {
    T data;
    TreeNode left;
    TreeNode right;

    public TreeNode(T data, TreeNode left, TreeNode right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public TreeNode(T data) {
        this.data = data;
    }
}