Height of Binary Tree in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the height of the binary tree.

DSA C

int height(struct Node* root) {
    if (root == NULL) {
        return [1];
    }
    // rest of the code
}

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

A0

B1

C-1

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 1 instead of -1 for an empty tree.

Returning NULL which is not an integer.

The height of an empty tree is -1, so we return -1 when the root is NULL.

2fill in blank

medium

Complete the code to calculate the height by comparing left and right subtree heights.

DSA C

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

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

A+

B<

C-

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of comparing heights.

Using '-' which gives wrong results.

Using '<' which selects the minimum height.

We need to find the maximum height between left and right subtrees, so we use the greater than operator to compare.

3fill in blank

hard

Fix the error in the code to correctly return the maximum height.

DSA C

int max(int a, int b) {
    if (a [1] b)
        return a;
    else
        return b;
}

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

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

A>

B<

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' which returns the smaller value.

Using '==' which checks equality, not size.

The max function should return 'a' if 'a' is greater than 'b'. So the correct operator is '>'.

4fill in blank

hard

Fill both blanks to complete the recursive height calculation using the max function.

DSA C

int height(struct Node* root) {
    if (root == NULL) {
        return [1];
    }
    int leftHeight = height(root->[2]);
    int rightHeight = height(root->right);
    return max(leftHeight, rightHeight) + 1;
}

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

A0

BNULL

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Returning NULL instead of 0.

Using root->right instead of root->left for left subtree.

Return 0 for empty tree. To get left subtree height, use root->left.

5fill in blank

hard

Fill all three blanks to complete the height function using max and recursive calls.

DSA C

int height(struct Node* root) {
    if (root == [1]) {
        return 0;
    }
    int leftHeight = height(root->[2]);
    int rightHeight = height(root->[3]);
    return max(leftHeight, rightHeight) + 1;
}

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

ANULL

Bleft

Cright

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root == 0 instead of NULL.

Using root->root which is invalid.

Check if root is NULL. Then recursively get left and right subtree heights using root->left and root->right.

Practice

1. What is the height of a binary tree with only one node (the root)?

easy

A. 0

B. 1

C. 2

D. Undefined

Solution

1. Step 1: Understand height definition

   The height of a binary tree is the number of edges on the longest path from the root to a leaf.

2. Step 2: Apply to single node tree

   With only one node (root), the longest path has length 0 edges.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   Height of single node tree = 0 [OK]

Hint: Height counts edges on longest root-to-leaf path [OK]

Common Mistakes:

• Thinking height is 1 for single node
• Confusing height with number of nodes
• Assuming height is undefined for single node

2. Which of the following is the correct C function signature to calculate the height of a binary tree node?

easy

A. void height(struct Node root);

B. int height(Node root);

C. int height(struct Node* root);

D. int height(struct Node root);

Solution

1. Step 1: Check parameter type for tree node

   In C, a tree node is usually passed as a pointer to struct Node.

2. Step 2: Check return type and parameter correctness

   The function returns an int (height) and takes a pointer to struct Node.

3. Final Answer:

   int height(struct Node* root); -> Option C

4. Quick Check:

   Correct signature uses pointer to struct Node [OK]

Hint: Use pointer to struct Node for tree parameters [OK]

Common Mistakes:

• Passing struct Node by value instead of pointer
• Using void return type instead of int
• Missing struct keyword in parameter

3. What is the output of the following code snippet calculating the height of this binary tree?

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

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

// Tree:
//     10
//    /  \
//   5    15
//        /
//       12

int main() {
  struct Node n12 = {12, NULL, NULL};
  struct Node n15 = {15, &n12, NULL};
  struct Node n5 = {5, NULL, NULL};
  struct Node n10 = {10, &n5, &n15};
  printf("%d", height(&n10));
  return 0;
}

medium

A. 1

B. 2

C. 4

D. 3

Solution

1. Step 1: Trace left subtree height

   Left subtree of root (10) has node 5 only, height = 1.

2. Step 2: Trace right subtree height

   Right subtree has nodes 15 and 12. Height is 2 (15 -> 12).

3. Step 3: Calculate total height

   Height = max(1, 2) + 1 (for root) = 3.

4. Final Answer:

   3 -> Option D

5. Quick Check:

   Height = 3 [OK]

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

Common Mistakes:

• Counting edges instead of nodes
• Ignoring one subtree height
• Off-by-one error in return statement

4. Identify the error in this height function and select the correct fix:

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

medium

A. Change base case return from -1 to 1

B. Change base case return from -1 to 0

C. Remove +1 from return statement

D. Change recursive calls to root->right and root->left swapped

Solution

1. Step 1: Understand base case meaning

   Base case returns height for empty tree. Returning -1 means height counts edges, not nodes.

2. Step 2: Fix base case for node count height

   To count nodes, base case should return 0 for NULL.

3. Final Answer:

   Change base case return from -1 to 0 -> Option B

4. Quick Check:

   Base case 0 for NULL node height [OK]

Hint: Base case for NULL should return 0 for node height [OK]

Common Mistakes:

• Returning -1 causes off-by-one height
• Removing +1 leads to wrong height
• Swapping left and right recursive calls unnecessary

5. Given a binary tree where each node has either 0 or 2 children, what is the height of a full binary tree with 7 nodes? Select the correct height.

hard

A. 3

B. 4

C. 2

D. 5

Solution

1. Step 1: Understand full binary tree properties

   A full binary tree with all nodes having 0 or 2 children has nodes count = 2^h - 1, where h is height.

2. Step 2: Calculate height from nodes count

   Given nodes = 7, solve 2^h - 1 = 7 -> 2^h = 8 -> h = 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Full binary tree height for 7 nodes = 3 [OK]

Hint: Full tree nodes = 2^height - 1 formula [OK]

Common Mistakes:

• Confusing height with number of edges
• Using incomplete binary tree formula
• Miscounting nodes or height