算法 - 判断平衡二叉树

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树
平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
示例1 输入 {1,2,3,4,5,6,7}
返回值 true

---

尝试一：

首先看到这个题目想到下面这个图；不同的分支同时向下，当某一侧的 left 和 right 均为空，而另一侧的 下下层都不为空时，那就是非平衡二叉树！但是这要怎么实现呢？

想到之前做过的 DFS，通过递归找到每一个子节点，那么，记录这一路径上结点的个数，将所有叶子节点所在路径上的节点个数放在集合中，最后判断结点最多的路径上的节点个数 - 结点路径最少的结点数量是不是大于 1，并将结果返回！此时注意！要考虑，只有单侧子树的问题，这时候，集合中仅有一个数据，这时一定要对集合中的个数进行判断，此时如果数中仅有根节点和一个左子节点，那么应该也算平衡二叉树吧！于是有如下代码：

//结点工具类
static class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
    public void List(ArrayList<Integer> res) {
        if (null != this.left) this.left.List(res);
        res.add(this.val);
        if (null != this.right) this.right.List(res);
    }
}

int count = 0;
//通过递归，将每一个子节点所在路径上的节点个数记录在集合中;注意此处的 count--;
private ArrayList helper(TreeNode root, ArrayList<Integer> res) {
    count++;
    if (null == root.left && null == root.right) {
        //到达叶子节点时，将其节点数存入集合中
        res.add(count);
    }
    if (null != root.left) helper(root.left, res);
    if (null != root.right) helper(root.right, res);
    count--;
    return res;
}
//注意此处返回时的判断条件
public boolean IsBalanced_Solution(TreeNode root) {
    if (null == root || (null == root.left && null == root.right)) return true;

    ArrayList<Integer> res = new ArrayList();
    ArrayList<Integer> list = helper(root, res);
    System.out.println("叶子节点长度：" + list);

    Collections.sort(list);
    return (list.size() > 1 && list.get(list.size() - 1) - list.get(0) < 2) || (list.size() == 1 && list.get(0) <= 2);
}

//测试工具类
public void test() {
    TreeNode root = new TreeNode(1);
    root.left = new TreeNode(2);
    root.left.left = new TreeNode(3);
    root.left.left.left = new TreeNode(5);
    root.left.left.left.left = new TreeNode(7);
    root.left.right = new TreeNode(4);
    root.right = new TreeNode(6);

    ArrayList res = new ArrayList();
    root.List(res);
    System.out.print("二叉树：" + res + " 是平衡二叉树吗？");
    boolean b = IsBalanced_Solution(root);
    System.out.println(b);
}

确实通过了测试，不过空间复杂度实在令人堪忧，首先是进行了递归找节点个数，递归本就耗费空间，再加上主方法中进行了对集合排序！这一定不是最优解！

---

正文来了

看到一篇比较精彩的解答，好的代码就是这样，第一眼看过去，你总以为他在闹着玩，仔细看看才发现小丑竟是我自己……

public boolean IsBalanced_Solution(TreeNode root) {
    return depth(root) != -1;
}

/**
* 返回 -1 表示不平衡；
* @param root
* @return
*/
public int depth(TreeNode root) {
    if (root == null) return 0;

    int left = depth(root.left);
    //如果发现子树不平衡之后就没有必要进行下面的高度的求解了
    if (left == -1) return -1;

    int right = depth(root.right);
    //如果发现子树不平衡之后就没有必要进行下面的高度的求解了
    if (right == -1) return -1;
    
    if (Math.abs(left - right) > 1) return -1;
    else return 1 + (left > right ? left : right);
}

emmm，秀是秀了点，但是空间复杂度没有很大的优化，还是使用递归，理解起来比较费劲，毕竟，自己对递归的流程没有那么熟悉，

---

最后，我要进大厂！加油奥里给！