# 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

• 
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);
}
}
}

############

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode() {}
*     TreeNode(int val) { this.val = val; }
*     TreeNode(int val, TreeNode left, TreeNode right) {
*         this.val = val;
*         this.left = left;
*         this.right = right;
*     }
* }
*/
class Solution {
public boolean isBalanced(TreeNode root) {
return height(root) >= 0;
}

private int height(TreeNode root) {
if (root == null) {
return 0;
}
int l = height(root.left);
int r = height(root.right);
if (l == -1 || r == -1 || Math.abs(l - r) > 1) {
return -1;
}
return 1 + Math.max(l, r);
}
}

• // 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:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
def isBalanced(self, root: Optional[TreeNode]) -> bool:
def height(root):
if root is None:
return 0
l, r = height(root.left), height(root.right)
if l == -1 or r == -1 or abs(l - r) > 1:
return -1
return 1 + max(l, r)

return height(root) >= 0

############

# 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


• /**
* Definition for a binary tree node.
* type TreeNode struct {
*     Val int
*     Left *TreeNode
*     Right *TreeNode
* }
*/
func isBalanced(root *TreeNode) bool {
var height func(*TreeNode) int
height = func(root *TreeNode) int {
if root == nil {
return 0
}
l, r := height(root.Left), height(root.Right)
if l == -1 || r == -1 || abs(l-r) > 1 {
return -1
}
if l > r {
return 1 + l
}
return 1 + r
}
return height(root) >= 0
}

func abs(x int) int {
if x < 0 {
return -x
}
return x
}

• /**
* Definition for a binary tree node.
* class TreeNode {
*     val: number
*     left: TreeNode | null
*     right: TreeNode | null
*     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
*         this.val = (val===undefined ? 0 : val)
*         this.left = (left===undefined ? null : left)
*         this.right = (right===undefined ? null : right)
*     }
* }
*/

function isBalanced(root: TreeNode | null): boolean {
const dfs = (root: TreeNode | null) => {
if (root == null) {
return 0;
}
const left = dfs(root.left);
const right = dfs(root.right);
if (left === -1 || right === -1 || Math.abs(left - right) > 1) {
return -1;
}
return 1 + Math.max(left, right);
};
return dfs(root) > -1;
}


• /**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
*     this.val = (val===undefined ? 0 : val)
*     this.left = (left===undefined ? null : left)
*     this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {boolean}
*/
var isBalanced = function (root) {
const height = root => {
if (!root) {
return 0;
}
const l = height(root.left);
const r = height(root.right);
if (l == -1 || r == -1 || Math.abs(l - r) > 1) {
return -1;
}
return 1 + Math.max(l, r);
};
return height(root) >= 0;
};


• // Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::rc::Rc;
use std::cell::RefCell;
impl Solution {
pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
Self::dfs(&root) > -1
}

fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> i32 {
if root.is_none() {
return 0;
}
let node = root.as_ref().unwrap().borrow();
let left = Self::dfs(&node.left);
let right = Self::dfs(&node.right);
if left == -1 || right == -1 || (left - right).abs() > 1 {
return -1;
}
1 + left.max(right)
}
}