Mirror a Binary Tree in DSA C - Build from Scratch

Mirror a Binary Tree

📖 Scenario: Imagine you have a family tree represented as a binary tree. You want to create a mirror image of this tree, swapping left and right children at every node.

🎯 Goal: Build a program in C that creates a binary tree, then mirrors it by swapping left and right children recursively, and finally prints the mirrored tree in inorder traversal.

📋 What You'll Learn

Define a binary tree node structure with integer data and left/right pointers

Create a binary tree with exactly 3 nodes: root with value 1, left child 2, right child 3

Create a function to mirror the binary tree by swapping left and right children recursively

Print the inorder traversal of the mirrored tree

💡 Why This Matters

🌍 Real World

Mirroring trees is useful in graphics, image processing, and reversing hierarchical data structures.

💼 Career

Understanding tree manipulations is important for software engineers working with data structures, algorithms, and system design.

1

Create the binary tree structure and initial tree

Define a struct called Node with an int data and two pointers left and right to Node. Then create three nodes: root with data 1, root->left with data 2, and root->right with data 3.

DSA C

# Define struct Node and create root, root->left, root->right nodes
// Your code here

Hint

Use typedef struct Node to define the node. Use malloc to create nodes and assign data values 1, 2, and 3.

2

Create a function to mirror the binary tree

Write a function called mirror that takes a pointer to Node called root. If root is not NULL, recursively call mirror on root->left and root->right, then swap root->left and root->right pointers.

DSA C

#include 
#include 

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

void mirror(Node* root) {
    // Your code here
}

int main() {
    Node* root = (Node*)malloc(sizeof(Node));
    root->data = 1;
    root->left = (Node*)malloc(sizeof(Node));
    root->left->data = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (Node*)malloc(sizeof(Node));
    root->right->data = 3;
    root->right->left = NULL;
    root->right->right = NULL;

    return 0;
}

Hint

Use recursion to call mirror on left and right children, then swap the pointers using a temporary variable.

3

Call the mirror function on the tree

In main, call the function mirror with the argument root to mirror the binary tree.

DSA C

#include 
#include 

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

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

int main() {
    Node* root = (Node*)malloc(sizeof(Node));
    root->data = 1;
    root->left = (Node*)malloc(sizeof(Node));
    root->left->data = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (Node*)malloc(sizeof(Node));
    root->right->data = 3;
    root->right->left = NULL;
    root->right->right = NULL;

    // Call mirror function here
    // Your code here

    return 0;
}

Hint

Simply call mirror(root); inside main before returning.

4

Print the inorder traversal of the mirrored tree

Write a function called inorder that takes a pointer to Node called root. It should print the data of nodes in inorder (left, root, right) traversal separated by spaces. Then call inorder(root) in main after mirroring the tree.

DSA C

#include 
#include 

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

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

void inorder(Node* root) {
    // Your code here
}

int main() {
    Node* root = (Node*)malloc(sizeof(Node));
    root->data = 1;
    root->left = (Node*)malloc(sizeof(Node));
    root->left->data = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (Node*)malloc(sizeof(Node));
    root->right->data = 3;
    root->right->left = NULL;
    root->right->right = NULL;

    mirror(root);

    // Call inorder here
    // Your code here

    return 0;
}

Hint

Use recursion to print left subtree, then root data, then right subtree. Call inorder(root); after mirroring and print a newline.

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