Question

Formatted question description: https://leetcode.ca/all/110.html

 110	Balanced Binary Tree

 Given a binary tree, determine if it is height-balanced.

 For this problem, a height-balanced binary tree is defined as:
    a binary tree in which the left and right subtrees of every node differ in height by no more than 1.



 Example 1:

 Given the following tree [3,9,20,null,null,15,7]:

    3
   / \
  9  20
 /  \
15   7
 Return true.

 Example 2:

 Given the following tree [1,2,2,3,3,null,null,4,4]:

        1
       / \
      2   2
    / \
   3   3
  / \
 4   4
 Return false.


 @tag-tree

Algorithm

If we find that the subtree is not balanced, the specific depth is not calculated, but -1 is directly returned. Then the optimized method is: For each node, we recursively obtain the depth of the left and right subtrees through the checkDepth method.

If the subtree is balanced, then return the true depth, if not, return directly to -1. This method is time-complex Degree O(N), space complexity O(H).

Code

Java

  • 
    public class Balanced_Binary_Tree {
        /**
         * Definition for binary tree
         * public class TreeNode {
         *     int val;
         *     TreeNode left;
         *     TreeNode right;
         *     TreeNode(int x) { val = x; }
         * }
         */
        public class Solution {
            public boolean isBalanced(TreeNode root) {
                // optimization!!!
    
                return maxDepth(root) != -1;
            }
    
            public int maxDepth(TreeNode root) {
    
                if (root == null) {
                    return 0;
                }
    
                int leftDepth = maxDepth(root.left);
                if (leftDepth == -1) {
                    return -1;
                }
    
                int rightDepth = maxDepth(root.right);
                if (rightDepth == -1) {
                    return -1;
                }
    
                return Math.abs(leftDepth - rightDepth) > 1 ? -1 : 1 + Math.max(leftDepth, rightDepth);
            }
        }
    }
    
  • // OJ: https://leetcode.com/problems/balanced-binary-tree/
    // Time: O(N)
    // Space: O(H)
    class Solution {
    private:
        bool isBalanced(TreeNode* root, int &h) {
            h = 0;
            if (!root) return true;
            int L = 0, R = 0;
            bool b = isBalanced(root->left, L) && isBalanced(root->right, R) && abs(L - R) <= 1;
            h = 1 + max(L, R);
            return b;
        }
    public:
        bool isBalanced(TreeNode* root) {
            int h;
            return isBalanced(root, h);
        }
    };
    
  • # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class Solution(object):
      def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
    
        def dfs(p):
          if not p:
            return 0
    
          left = dfs(p.left)
          right = dfs(p.right)
          if left == -1 or right == -1:
            return -1
          if abs(left - right) > 1:
            return -1
          return 1 + max(left, right)
    
        if dfs(root) == -1:
          return False
        return True
    
    

All Problems

All Solutions