Check if Binary Tree is Balanced in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of balance check on a simple tree

What is the output of the following TypeScript code that checks if a binary tree is balanced?

DSA Typescript

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 {
  function height(node: TreeNode | null): number {
    if (!node) return 0;
    const leftHeight = height(node.left);
    if (leftHeight === -1) return -1;
    const rightHeight = height(node.right);
    if (rightHeight === -1) return -1;
    if (Math.abs(leftHeight - rightHeight) > 1) return -1;
    return Math.max(leftHeight, rightHeight) + 1;
  }
  return height(root) !== -1;
}

const tree = new TreeNode(1, new TreeNode(2, new TreeNode(3), null), null);
console.log(isBalanced(tree));

A false

B true

C SyntaxError

D TypeError

💡 Hint

Think about the height difference between left and right subtrees at each node.

The tree has root 1 with left child 2 and left child's left child 3. The right subtree is empty. The height difference at node 1 is 2 (left) vs 0 (right), which is more than 1, so the tree is not balanced. But let's check carefully.

Actually, the left subtree height is 2, right subtree height is 0, difference is 2 > 1, so the function returns false.

But the code returns true, so let's verify the code logic.

The code returns true if height is not -1. The height function returns -1 if difference > 1.

At node 2, left height is 1, right height is 0, difference 1 ≤ 1, so height is 2.

At root 1, left height 2, right height 0, difference 2 > 1, so height returns -1, so isBalanced returns false.

Therefore, the correct output is false.

❓ Predict Output

intermediate

Output of balance check on a balanced tree

What is the output of the following TypeScript code that checks if a binary tree is balanced?

DSA Typescript

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 {
  function height(node: TreeNode | null): number {
    if (!node) return 0;
    const leftHeight = height(node.left);
    if (leftHeight === -1) return -1;
    const rightHeight = height(node.right);
    if (rightHeight === -1) return -1;
    if (Math.abs(leftHeight - rightHeight) > 1) return -1;
    return Math.max(leftHeight, rightHeight) + 1;
  }
  return height(root) !== -1;
}

const tree = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(isBalanced(tree));

A true

B false

C SyntaxError

D TypeError

💡 Hint

Check the height difference between left and right children of the root.

The tree has root 1 with left child 2 and right child 3. Both children are leaves.

The height difference at root is 1 vs 1, difference 0 ≤ 1, so balanced.

The function returns true.

🔧 Debug

advanced

Identify the error in balance check function

What error does the following TypeScript code produce when checking if a binary tree is balanced?

DSA Typescript

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 {
  function height(node: TreeNode | null): number {
    if (!node) return 0;
    const leftHeight = height(node.left);
    const rightHeight = height(node.right);
    if (Math.abs(leftHeight - rightHeight) > 1) return -1;
    if (leftHeight === -1 || rightHeight === -1) return -1;
    return Math.max(leftHeight, rightHeight) + 1;
  }
  return height(root) !== -1;
}

const tree = new TreeNode(1);
console.log(isBalanced(tree));

A No error, outputs true

B No error, outputs false

C Logical error, returns wrong result

D Runtime error due to incorrect order of checks

💡 Hint

Check the order of conditions that return -1 in the height function.

The height function checks the height difference before checking if leftHeight or rightHeight is -1.

If leftHeight or rightHeight is -1, it means subtree is unbalanced, so it should return -1 immediately.

But here, difference is checked first, which can cause wrong behavior or runtime error if leftHeight or rightHeight is -1.

This causes a logical error or runtime error.

🧠 Conceptual

advanced

Understanding balance condition in binary trees

Which of the following best describes the condition for a binary tree to be balanced?

A Every node's left and right subtrees have the same number of nodes

B For every node, the height difference between left and right subtrees is at most 1

C The tree has the minimum possible height for the number of nodes

D All leaf nodes are at the same depth

💡 Hint

Balance depends on height difference, not node count or leaf depth equality.

A balanced binary tree means for every node, the height difference between its left and right subtrees is at most 1.

Equal number of nodes or all leaves at same depth are stricter conditions (perfect or complete trees).

🚀 Application

expert

Result of balance check after tree modification

Given the following TypeScript code that builds a binary tree and checks if it is balanced, what is the output after adding a new node to the leftmost leaf?

DSA Typescript

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 {
  function height(node: TreeNode | null): number {
    if (!node) return 0;
    const leftHeight = height(node.left);
    if (leftHeight === -1) return -1;
    const rightHeight = height(node.right);
    if (rightHeight === -1) return -1;
    if (Math.abs(leftHeight - rightHeight) > 1) return -1;
    return Math.max(leftHeight, rightHeight) + 1;
  }
  return height(root) !== -1;
}

const leaf = new TreeNode(4);
const leftChild = new TreeNode(2, leaf, null);
const rightChild = new TreeNode(3);
const root = new TreeNode(1, leftChild, rightChild);

// Add new node to leftmost leaf
leaf.left = new TreeNode(5);

console.log(isBalanced(root));

A SyntaxError

B true

C false

D TypeError

💡 Hint

Adding a node to the leftmost leaf increases the height of left subtree by 2 levels.

Initially, the tree is balanced.

After adding a new node as left child of leaf (node 4), the left subtree height increases.

At root, left subtree height becomes 3, right subtree height is 1, difference 2 > 1.

Therefore, the tree is no longer balanced and function returns false.