Check if Binary Tree is Balanced in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the struct for a binary tree node.

DSA C

typedef struct Node {
    int data;
    struct Node* [1];
    struct Node* right;
} Node;

Drag options to blanks, or click blank then click option'

Aleft

Bchild

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using generic names like 'child' or 'next' instead of 'left'.

The left child pointer in a binary tree node is commonly named left.

2fill in blank

medium

Complete the code to calculate the height of a binary tree node.

DSA C

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

Drag options to blanks, or click blank then click option'

Anext

Bright

Cchild

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pointer names like 'child' or 'next'.

The height function recursively calls itself on the right child, which is accessed by root->right.

3fill in blank

hard

Fix the error in the condition that checks if the tree is balanced.

DSA C

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

Drag options to blanks, or click blank then click option'

A<

B!=

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using equality or less than operators which do not correctly detect imbalance.

The tree is unbalanced if the height difference is greater than 1, so the condition should be abs(lh - rh) > 1.

4fill in blank

hard

Fill both blanks to complete the function that returns the height and checks balance in one traversal.

DSA C

int checkHeight(Node* root) {
    if (root == NULL) return 0;
    int leftHeight = checkHeight(root->[1]);
    if (leftHeight == -1) return -1;
    int rightHeight = checkHeight(root->[2]);
    if (rightHeight == -1) return -1;
    if (abs(leftHeight - rightHeight) > 1) return -1;
    return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}

Drag options to blanks, or click blank then click option'

Aleft

Bchild

Cright

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pointer names like 'child' or 'next'.

The function recursively checks the left and right subtrees using root->left and root->right.

5fill in blank

hard

Fill all three blanks to complete the main function that uses the optimized checkHeight to determine if the tree is balanced.

DSA C

int isBalanced(Node* root) {
    int result = checkHeight([1]);
    if (result [2]  -1) {
        return [3];
    }
    return 1;
}

Drag options to blanks, or click blank then click option'

Aroot

B==

C0

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison operators or returning incorrect values.

The function calls checkHeight(root), checks if the result equals -1, and returns 0 (false) if unbalanced.

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