Mirror a Binary Tree in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to swap the left and right child nodes of the root.

DSA C

void mirror(struct Node* root) {
    if (root == NULL) return;
    struct Node* temp = root->[1];
    root->left = root->right;
    root->right = temp;
}

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

Aleft

Bright

Cdata

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

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

Trying to swap data instead of child pointers.

We store the left child in temp before swapping. So temp must be root->left.

2fill in blank

medium

Complete the code to recursively call mirror on the left subtree.

DSA C

void mirror(struct Node* root) {
    if (root == NULL) return;
    // Swap children
    struct Node* temp = root->left;
    root->left = root->right;
    root->right = temp;
    mirror(root->[1]);
    mirror(root->right);
}

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

Aparent

Bdata

Cright

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Calling mirror on root->right twice.

Calling mirror on root->data or root->parent.

After swapping, we call mirror on the new left subtree, which was originally the right subtree.

3fill in blank

hard

Fix the error in the base case check to stop recursion.

DSA C

void mirror(struct Node* root) {
    if (root == [1]) return;
    struct Node* temp = root->left;
    root->left = root->right;
    root->right = temp;
    mirror(root->left);
    mirror(root->right);
}

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

A0

Broot

CNULL

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if root == 0 instead of NULL.

Checking if root == false or root itself.

The base case checks if root is NULL to stop recursion.

4fill in blank

hard

Fill both blanks to complete the recursive calls for mirroring both subtrees.

DSA C

void mirror(struct Node* root) {
    if (root == NULL) return;
    struct Node* temp = root->left;
    root->left = root->right;
    root->right = temp;
    mirror(root->[1]);
    mirror(root->[2]);
}

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

Aleft

Bright

Cdata

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Calling mirror on data or parent instead of child pointers.

Calling mirror on the same child twice.

We recursively call mirror on both left and right children after swapping.

5fill in blank

hard

Fill all three blanks to complete the mirror function with base case, swap, and recursive calls.

DSA C

void mirror(struct Node* root) {
    if (root == [1]) return;
    struct Node* temp = root->[2];
    root->left = root->[3];
    root->right = temp;
    mirror(root->left);
    mirror(root->right);
}

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

ANULL

Bleft

Cright

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Using data or wrong pointers for swapping.

Missing the base case or swapping incorrectly.

Base case checks for NULL, temp stores left child, then left is assigned right child.

Practice

1. What does mirroring a binary tree mean?

easy

A. Sorting the nodes in ascending order

B. Swapping the left and right children of every node in the tree

C. Removing all leaf nodes from the tree

D. Counting the total number of nodes in the tree

Solution

1. Step 1: Understand the mirror operation

   Mirroring a binary tree means swapping the left and right children of every node.

2. Step 2: Identify the effect on the tree

   This operation flips the tree around its center, creating a mirror image.

3. Final Answer:

   Swapping the left and right children of every node in the tree -> Option B

4. Quick Check:

   Mirror = Swap children [OK]

Hint: Mirror means swap left and right children at all nodes [OK]

Common Mistakes:

• Thinking mirror means sorting nodes
• Confusing mirror with deleting nodes
• Assuming mirror counts nodes

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

easy

A. void mirrorTree(struct Node* root);

B. int mirrorTree(struct Node root);

C. struct Node mirrorTree(struct Node* root);

D. void mirrorTree(struct Node root);

Solution

1. Step 1: Understand parameter passing for trees in C

   Binary trees are usually passed as pointers to nodes to allow modification.

2. Step 2: Identify correct return type

   Mirroring modifies the tree in place, so the function returns void.

3. Final Answer:

   void mirrorTree(struct Node* root); -> Option A

4. Quick Check:

   Pointer parameter + void return = void mirrorTree(struct Node* root); [OK]

Hint: Use pointer to root and void return for in-place mirror [OK]

Common Mistakes:

• Passing struct Node by value instead of pointer
• Returning struct Node instead of void
• Using int return type incorrectly

3. What will be the output of the following code snippet after mirroring the binary tree?

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

void mirrorTree(struct Node* root) {
  if (root == NULL) return;
  struct Node* temp = root->left;
  root->left = root->right;
  root->right = temp;
  mirrorTree(root->left);
  mirrorTree(root->right);
}

// Tree before mirror:
//     1
//    / \
//   2   3
//  /     \
// 4       5

// After mirror, print preorder traversal:
// Expected output?

medium

A. 1 2 3 4 5

B. 1 2 4 3 5

C. 1 3 2 5 4

D. 1 3 5 2 4

Solution

1. Step 1: Understand the mirror operation on the tree

   Swapping left and right children at every node flips the tree: Original root 1 has left=2, right=3 After mirror: left=3, right=2 Node 2 has left=4, right=NULL After mirror: left=NULL, right=4 Node 3 has left=NULL, right=5 After mirror: left=5, right=NULL

2. Step 2: Perform preorder traversal on mirrored tree

   Preorder: root, left, right Visit 1 Go left to 3 Go left to 5 (leaf) Back to 1, go right to 2 Go left NULL, go right 4 Sequence: 1 3 5 2 4

3. Final Answer:

   1 3 5 2 4 -> Option D

4. Quick Check:

   Mirror + preorder = 1 3 5 2 4 [OK]

Hint: Mirror swaps children; preorder visits root-left-right [OK]

Common Mistakes:

• Not swapping children correctly
• Confusing preorder with inorder or postorder
• Missing leaf nodes in traversal

4. Identify the error in the following mirror function and select the fix:

void mirrorTree(struct Node* root) {
  if (root == NULL) return;
  mirrorTree(root->left);
  struct Node* temp = root->left;
  root->left = root->right;
  root->right = temp;
  mirrorTree(root->right);
}

medium

A. Add return type as int instead of void

B. Remove the base case check for NULL

C. Swap children before recursive calls to mirrorTree

D. Change temp to int instead of struct Node*

Solution

1. Step 1: Analyze the order of operations in the function

   The function calls mirrorTree on left and right children before swapping them. This causes the recursive calls to work on original children, not swapped ones.

2. Step 2: Correct the order to swap first, then recurse

   Swapping children first ensures recursive calls mirror the swapped subtrees correctly.

3. Final Answer:

   Swap children before recursive calls to mirrorTree -> Option C

4. Quick Check:

   Swap first, recurse later [OK]

Hint: Swap children before recursion to mirror correctly [OK]

Common Mistakes:

• Swapping after recursion causes incorrect mirror
• Removing base case causes crashes
• Changing temp type breaks pointer logic

5. Given a binary tree where some nodes have only one child, what is the effect of mirroring the tree on the structure and leaf nodes? Choose the correct statement.

hard

A. All leaf nodes remain leaf nodes but their positions are mirrored

B. Some leaf nodes become internal nodes after mirroring

C. The number of leaf nodes doubles after mirroring

D. Mirroring removes all nodes with only one child

Solution

1. Step 1: Understand mirroring effect on node positions

   Mirroring swaps left and right children but does not add or remove nodes. Leaf nodes remain leaf nodes but their positions flip left to right.

2. Step 2: Confirm leaf nodes count and structure

   Number of leaf nodes stays the same; no nodes become internal or are removed. Only their left-right positions change.

3. Final Answer:

   All leaf nodes remain leaf nodes but their positions are mirrored -> Option A

4. Quick Check:

   Mirror flips positions, leaf count unchanged [OK]

Hint: Mirror flips positions, leaf nodes stay leaf nodes [OK]

Common Mistakes:

• Thinking leaf nodes become internal nodes
• Assuming nodes are added or removed
• Believing leaf count changes