题目描述
输入一棵二叉树,判断该二叉树是否是平衡二叉树。
在这里,我们只需要考虑其平衡性,不需要考虑其是不是排序二叉树
平衡二叉树(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,秀是秀了点,但是空间复杂度没有很大的优化,还是使用递归,理解起来比较费劲,毕竟,自己对递归的流程没有那么熟悉,
最后,我要进大厂!加油奥里给!