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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of balance check on a simple binary tree

What is the output of the following C code that checks if a binary tree is balanced? The function returns 1 if balanced, 0 otherwise.

DSA C

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

int max(int a, int b) {
    return (a > b) ? a : b;
}

int height(Node* root) {
    if (root == NULL) return 0;
    return 1 + max(height(root->left), height(root->right));
}

int isBalanced(Node* root) {
    if (root == NULL) return 1;
    int lh = height(root->left);
    int rh = height(root->right);
    if (abs(lh - rh) > 1) return 0;
    return isBalanced(root->left) && isBalanced(root->right);
}

int main() {
    Node n1 = {1, NULL, NULL};
    Node n2 = {2, &n1, NULL};
    Node n3 = {3, NULL, NULL};
    Node root = {4, &n2, &n3};
    int result = isBalanced(&root);
    printf("%d\n", result);
    return 0;
}

A 1

B 2

C 0

D Compilation error

💡 Hint

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

The tree is balanced because the height difference between left and right subtrees of every node is at most 1.

❓ Predict Output

intermediate

Output for unbalanced binary tree

What does the following C code print when checking if the binary tree is balanced?

DSA C

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

int max(int a, int b) {
    return (a > b) ? a : b;
}

int height(Node* root) {
    if (root == NULL) return 0;
    return 1 + max(height(root->left), height(root->right));
}

int isBalanced(Node* root) {
    if (root == NULL) return 1;
    int lh = height(root->left);
    int rh = height(root->right);
    if (abs(lh - rh) > 1) return 0;
    return isBalanced(root->left) && isBalanced(root->right);
}

int main() {
    Node n1 = {1, NULL, NULL};
    Node n2 = {2, &n1, NULL};
    Node n3 = {3, NULL, NULL};
    Node n4 = {4, &n2, NULL};
    int result = isBalanced(&n4);
    printf("%d\n", result);
    return 0;
}

A 1

B Runtime error

C 2

D 0

💡 Hint

Check the height difference at node 4.

The tree is unbalanced because the left subtree of node 4 has height 3 and right subtree is NULL (height 0), difference is 3 > 1.

🧠 Conceptual

advanced

Time complexity of naive balanced tree check

What is the time complexity of the naive approach to check if a binary tree is balanced, where height is computed separately for each node?

A O(n)

B O(n log n)

C O(n^2)

D O(log n)

💡 Hint

Consider that height is computed repeatedly for overlapping subtrees.

The naive approach calls height for each node, and height itself is O(n) in worst case, leading to O(n^2) overall.

🚀 Application

advanced

Optimized balanced tree check returns -1 for unbalanced

In an optimized function, height returns -1 if subtree is unbalanced. What does the function return for the following tree?

DSA C

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

int checkHeight(Node* root) {
    if (root == NULL) return 0;
    int lh = checkHeight(root->left);
    if (lh == -1) return -1;
    int rh = checkHeight(root->right);
    if (rh == -1) return -1;
    if (abs(lh - rh) > 1) return -1;
    return 1 + (lh > rh ? lh : rh);
}

int main() {
    Node n1 = {1, NULL, NULL};
    Node n2 = {2, &n1, NULL};
    Node n3 = {3, NULL, NULL};
    Node root = {4, &n2, &n3};
    int result = checkHeight(&root);
    printf("%d\n", result);
    return 0;
}

A 3

B -1

C 2

D 0

💡 Hint

Calculate height bottom-up and check for -1 return.

The tree is balanced, so function returns height 3.

🔧 Debug

expert

Identify error in balanced tree check code

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

DSA C

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

int height(Node* root) {
    if (root == NULL) return 0;
    return 1 + (height(root->left) > height(root->right) ? height(root->left) : height(root->right));
}

int isBalanced(Node* root) {
    if (root == NULL) return 1;
    int lh = height(root->left);
    int rh = height(root->right);
    if (abs(lh - rh) > 1) return 0;
    return isBalanced(root->left) && isBalanced(root->right);
}

int main() {
    Node n1 = {1, NULL, NULL};
    Node n2 = {2, &n1, NULL};
    Node n3 = {3, NULL, NULL};
    Node root = {4, &n2, &n3};
    int result = isBalanced(&root);
    printf("%d\n", result);
    return 0;
}

A Correct output 1

B Stack overflow due to infinite recursion

C Compilation error due to missing headers

D Runtime error due to null pointer dereference

💡 Hint

Look carefully at the height function calls inside itself.

The height function calls height(root->left) and height(root->right) twice each, causing exponential recursion and stack overflow.

Practice

1. What does it mean for a binary tree to be balanced?

easy

A. The height difference between left and right subtrees of every node is at most 1

B. All nodes have two children

C. The tree has the same number of nodes on left and right

D. The tree is a complete binary tree

Solution

1. Step 1: Understand balance condition

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

2. Step 2: Compare other options

   Other options describe different tree properties but not the balance condition.

3. Final Answer:

   The height difference between left and right subtrees of every node is at most 1 -> Option A

4. Quick Check:

   Balance means height difference ≤ 1 [OK]

Hint: Balance means height difference ≤ 1 at every node [OK]

Common Mistakes:

• Confusing balanced with complete tree
• Thinking balance means equal number of nodes
• Assuming all nodes must have two children

2. Which of the following C function signatures is correct to check if a binary tree is balanced?

easy

A. bool isBalanced(struct Node root);

B. void isBalanced(struct Node root);

C. int isBalanced(Node root);

D. int isBalanced(struct Node* root);

Solution

1. Step 1: Check parameter type

   The function should take a pointer to the root node: struct Node* root.

2. Step 2: Check return type

   Return type int is common for boolean checks in C (0 or 1).

3. Final Answer:

   int isBalanced(struct Node* root); -> Option D

4. Quick Check:

   Pointer parameter and int return type [OK]

Hint: Use pointer to struct and int return for boolean in C [OK]

Common Mistakes:

• Passing struct by value instead of pointer
• Using void return type for boolean check
• Missing struct keyword in parameter

3. What will be the output of the following code snippet?

struct Node {
  int data;
  struct Node* left;
  struct Node* right;
};

int height(struct Node* root) {
  if (!root) return 0;
  int leftHeight = height(root->left);
  int rightHeight = height(root->right);
  return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}

int isBalanced(struct Node* root) {
  if (!root) return 1;
  int leftHeight = height(root->left);
  int rightHeight = height(root->right);
  if (abs(leftHeight - rightHeight) > 1) return 0;
  return isBalanced(root->left) && isBalanced(root->right);
}

// Tree:
//     1
//    / \
//   2   3
//  /
// 4

int main() {
  struct Node n4 = {4, NULL, NULL};
  struct Node n2 = {2, &n4, NULL};
  struct Node n3 = {3, NULL, NULL};
  struct Node n1 = {1, &n2, &n3};
  printf("%d", isBalanced(&n1));
  return 0;
}

medium

A. Undefined behavior

B. 0

C. 1

D. Compilation error

Solution

1. Step 1: Calculate heights of subtrees

   Node 2's left subtree height is 1 (node 4), right subtree is 0, difference 1 ≤ 1. Node 1's left subtree height is 2, right subtree height is 1, difference 1 ≤ 1.

2. Step 2: Check balance recursively

   All nodes satisfy balance condition, so isBalanced returns 1 (true).

3. Final Answer:

   1 -> Option C

4. Quick Check:

   Height difference ≤ 1 at all nodes means balanced [OK]

Hint: Check height difference ≤ 1 at every node recursively [OK]

Common Mistakes:

• Ignoring recursive balance check on subtrees
• Miscomputing height values
• Assuming difference > 0 means unbalanced

4. Identify the bug in this code snippet that checks if a binary tree is balanced:

int height(struct Node* root) {
  if (!root) return 0;
  int leftHeight = height(root->left);
  int rightHeight = height(root->right);
  return leftHeight + rightHeight + 1;
}

int isBalanced(struct Node* root) {
  if (!root) return 1;
  int leftHeight = height(root->left);
  int rightHeight = height(root->right);
  if (abs(leftHeight - rightHeight) > 1) return 0;
  return isBalanced(root->left) && isBalanced(root->right);
}

medium

A. abs function is not included from math.h

B. height function incorrectly sums left and right heights

C. isBalanced does not check for NULL root

D. isBalanced returns int instead of bool

Solution

1. Step 1: Analyze height function logic

   The height function incorrectly returns leftHeight + rightHeight + 1 instead of max(leftHeight, rightHeight) + 1.

2. Step 2: Understand impact on balance check

   Incorrect height causes wrong height difference, leading to wrong balance result.

3. Final Answer:

   height function incorrectly sums left and right heights -> Option B

4. Quick Check:

   Height = max(left, right) + 1, not sum [OK]

Hint: Height = max(left, right) + 1, not sum [OK]

Common Mistakes:

• Summing heights instead of taking max
• Ignoring NULL checks (though present here)
• Confusing return types for boolean

5. Given a binary tree where some nodes have only one child, which approach correctly checks if it is balanced? Choose the best method to implement isBalanced efficiently.

hard

A. Use a helper function that returns height and balance status simultaneously in one traversal

B. Calculate height for each node repeatedly in isBalanced causing O(n²) time

C. Check balance only at root node ignoring subtrees

D. Count total nodes and compare left and right subtree counts

Solution

1. Step 1: Understand naive approach

   Calculating height separately for each node causes repeated work and O(n²) time complexity.

2. Step 2: Efficient approach

   Using a helper function that returns both height and balance status in one traversal reduces time to O(n).

3. Final Answer:

   Use a helper function that returns height and balance status simultaneously in one traversal -> Option A

4. Quick Check:

   Single traversal with combined info is efficient [OK]

Hint: Combine height and balance check in one traversal [OK]

Common Mistakes:

• Recomputing heights multiple times
• Ignoring subtree balance checks
• Using node counts instead of heights