剑指 Offer 55 - II. 平衡二叉树(js)

剑指 Offer 55 - II. 平衡二叉树

一节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

      1
      / \
     2   2
    / \
   3   3
  / \
 4   4
返回 false 。

限制：

0 <= 树的结点个数 <= 10000

解题一：深度搜索+层序遍历，其它看注释

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isBalanced = function(root) {
    search(root);
    return isBalancedTree(root)
};
//后序遍历，计算每个节点的左右子树深度
var search = function(root) {
    if(root===null) {
        return 0;
    }
    root.leftDepth = search(root.left) + 1;
    root.rightDepth = search(root.right) + 1;
    return Math.max(root.leftDepth,root.rightDepth)
}
//层序遍历，计算遍历的节点的左右子树的深度差，如果大于1就退出循环
var isBalancedTree = function(root) {
    if(root==null) {return true;}
    let queue = [root];
    while(queue.length) {
        let tmp = []
        for(let i=0,len=queue.length;i<len;i++){
            let nodetmp = queue[i];
            let depth = Math.abs(nodetmp.leftDepth-nodetmp.rightDepth) 
            if(depth>1) {return false;}
            if(nodetmp.left!==null) {
                tmp.push(queue[i].left)
            }
            if(nodetmp.right!==null) {
                tmp.push(queue[i].right)
            }
        }
        queue=tmp;
    }
    return true;
}

解题二：解题一的优化版，深度搜索就可以处理掉左右子树深度是否大于1

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isBalanced = function(root) {
    return dfs(root)!==-1;
};
//深度搜索，一旦返回-1就一直保持返回-1（-1表示深度大于-1，也就是不平衡二叉树）
var dfs = function(root) {
    if(root===null) {
        return 0;
    }
    let left = dfs(root.left)
    if(left===-1) { //一旦是-1，就不需要计算深度，只需返回-1
        return -1;
    }
    let right = dfs(root.right)
    if(right===-1) { //一旦是-1，就不需要计算深度，只需返回-1
        return -1;
    }
    return Math.abs(left-right)>1?-1:Math.max(left,right)+1;//如果深度>1，就会返回-1，要不然就返回深度
}