Mirror a Binary Tree in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean to mirror a binary tree?

Mirroring a binary tree means swapping the left and right children of every node in the tree, creating a mirror image of the original tree.

intermediate

Which traversal method is commonly used to mirror a binary tree?

A post-order traversal is commonly used because it processes child nodes before the parent, allowing safe swapping of left and right children.

beginner

In C, how do you swap the left and right children of a binary tree node?

Use a temporary pointer to hold one child, assign the other child to the first, then assign the temporary pointer to the second child, e.g.,

TreeNode* temp = node->left;
node->left = node->right;
node->right = temp;

beginner

What is the time complexity of mirroring a binary tree with n nodes?

The time complexity is O(n) because each node is visited once to swap its children.

beginner

Why is it important to check if a node is NULL before mirroring its children?

Checking for NULL prevents accessing invalid memory and stops recursion at leaf nodes, avoiding errors.

What happens to the left and right children of each node when mirroring a binary tree?

A They are duplicated

B They are deleted

C They are swapped

D They remain the same

Mirroring swaps the left and right children of every node.

Which traversal order is best suited for mirroring a binary tree?

A Post-order

B In-order

C Pre-order

D Level-order

Post-order traversal processes children before the parent, allowing safe swapping.

What is the base case for the recursive mirror function on a binary tree node?

A Node has two children

B Node has only one child

C Node is a leaf

D Node is NULL

The recursion stops when the node is NULL.

What is the time complexity of mirroring a binary tree with n nodes?

A O(log n)

B O(n)

C O(1)

D O(n log n)

Each node is visited once, so the complexity is O(n).

In C, which data type is used to temporarily hold a child node during swapping?

A TreeNode*

B int

C char

D float

A pointer to TreeNode (TreeNode*) is used to hold the child node temporarily.

Explain step-by-step how to mirror a binary tree using recursion.

Think about visiting children before swapping.

Describe how you would implement the mirror function in C for a binary tree node.

Use recursion and pointer swapping.

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