Mirror a Binary Tree in DSA Python - Build from Scratch

Mirror a Binary Tree

📖 Scenario: You are working with a simple binary tree data structure. Sometimes, you need to flip the tree so that the left and right children of every node are swapped. This is called mirroring a binary tree.Imagine a family tree photo where you want to swap the left and right sides to see the mirror image.

🎯 Goal: Build a program that creates a binary tree, then writes a function to mirror it by swapping left and right children at every node, and finally prints the mirrored tree in a readable format.

📋 What You'll Learn

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

Create a function called mirror_tree that takes the root node and swaps its left and right children recursively

Print the tree nodes in pre-order traversal (root, left, right) after mirroring

💡 Why This Matters

🌍 Real World

Mirroring binary trees is useful in image processing, graphics, and reversing tree-based data structures.

💼 Career

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

1

Create the binary tree nodes

Create a class called Node with an __init__ method that takes value, left, and right parameters. Then create three nodes: root with value 1, left child with value 2, and right child with value 3. Connect the left and right children to the root node.

DSA Python

# Define Node class and create root, left, right nodes
# Your code here

Hint

Define a Node class with value, left, and right. Then create root and assign its left and right children.

2

Define the mirror function

Define a function called mirror_tree that takes a node as input. If the node is not None, swap its left and right children, then recursively call mirror_tree on the left and right children.

DSA Python

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

root = Node(1)
root.left = Node(2)
root.right = Node(3)

# Define mirror_tree function below
# Your code here

Hint

Use recursion to swap left and right children for each node.

3

Call the mirror function on the root

Call the function mirror_tree with the variable root as the argument to mirror the entire tree.

DSA Python

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

root = Node(1)
root.left = Node(2)
root.right = Node(3)

def mirror_tree(node):
    if node is None:
        return
    node.left, node.right = node.right, node.left
    mirror_tree(node.left)
    mirror_tree(node.right)

# Call mirror_tree on root
# Your code here

Hint

Simply call mirror_tree(root) to start mirroring from the root node.

4

Print the mirrored tree in pre-order

Define a function called print_preorder that takes a node and prints its value, then recursively prints the left and right children in pre-order. Then call print_preorder with root to display the mirrored tree.

DSA Python

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

root = Node(1)
root.left = Node(2)
root.right = Node(3)

def mirror_tree(node):
    if node is None:
        return
    node.left, node.right = node.right, node.left
    mirror_tree(node.left)
    mirror_tree(node.right)

mirror_tree(root)

# Define print_preorder and call it with root
# Your code here

Hint

Print the node value first, then recursively print left and right children to get pre-order output.

Practice

1. What does mirroring a binary tree mean?
Mirror a Binary Tree means:

easy

A. Swapping the left and right children of every node

B. Deleting all leaf nodes

C. Reversing the values of nodes in each level

D. Sorting the nodes in ascending order

Solution

1. Step 1: Understand the mirror operation

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

2. Step 2: Compare with other options

   Deleting leaves, reversing values, or sorting nodes are different operations and do not create a mirror image.

3. Final Answer:

   Swapping the left and right children of every node -> Option A

4. Quick Check:

   Mirror = Swap children [OK]

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

Common Mistakes:

• Thinking mirror means reversing node values only
• Confusing mirror with tree traversal
• Assuming mirror deletes nodes

2. Which of the following is the correct Python function header to define a recursive mirror function for a binary tree node named root?

easy

A. def mirror(root):

B. def mirror(root) -> int:

C. def mirror(root) -> None:

D. def mirror(root) -> str:

Solution

1. Step 1: Identify function purpose and return type

   The mirror function modifies the tree in place and returns nothing, so return type is None.

2. Step 2: Check syntax correctness

   def mirror(root) -> None: uses correct Python syntax with type hint for no return value.

3. Final Answer:

   def mirror(root) -> None: -> Option C

4. Quick Check:

   Function returns nothing = None [OK]

Hint: Mirror modifies tree, returns nothing, so use -> None [OK]

Common Mistakes:

• Using wrong return type like int or str
• Omitting parentheses in function definition
• Missing colon at end of function header

3. What will be the output of the following code after calling mirror(root)? Assume the tree is:
1
/ \
2 3

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def mirror(root) -> None:
    if root is None:
        return
    root.left, root.right = root.right, root.left
    mirror(root.left)
    mirror(root.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
mirror(root)
print(root.left.val, root.right.val)

medium

A. 1 3

B. 3 2

C. 2 3

D. 3 1

Solution

1. Step 1: Understand initial tree structure

   Root is 1, left child 2, right child 3.

2. Step 2: Apply mirror function

   Mirror swaps left and right children at root, so left becomes 3 and right becomes 2.

3. Final Answer:

   3 2 -> Option B

4. Quick Check:

   Swapped children = 3 2 [OK]

Hint: Mirror swaps children, so left=3 and right=2 after mirror [OK]

Common Mistakes:

• Not swapping children correctly
• Printing values before mirror call
• Confusing left and right child values

4. Find the error in this mirror function code:

def mirror(root):
    if root is None:
        return
    mirror(root.left)
    mirror(root.right)
    root.left = root.right
    root.right = root.left

medium

A. Swapping left and right children is done incorrectly

B. Base case is missing

C. Function does not call itself recursively

D. No return statement in function

Solution

1. Step 1: Analyze swapping logic

   Assigning root.left = root.right then root.right = root.left sets both to same child, losing original left.

2. Step 2: Correct swapping method

   Use simultaneous swap: root.left, root.right = root.right, root.left to avoid overwriting.

3. Final Answer:

   Swapping left and right children is done incorrectly -> Option A

4. Quick Check:

   Swap must be simultaneous to avoid overwrite [OK]

Hint: Swap children simultaneously to avoid overwriting [OK]

Common Mistakes:

• Swapping children one by one causing data loss
• Forgetting base case for recursion
• Not swapping children at all

5. Given a binary tree, write a function to check if the tree is symmetric (a mirror of itself). Which approach correctly uses the mirror concept?

hard

A. Traverse tree in preorder and compare with inorder traversal

B. Check if left and right subtrees have the same number of nodes

C. Check if all node values are equal in left and right subtrees

D. Compare left subtree with right subtree by recursively checking if left.left matches right.right and left.right matches right.left

Solution

1. Step 1: Understand symmetry in binary trees

   A symmetric tree is a mirror of itself, so left subtree must mirror right subtree.

2. Step 2: Use recursive comparison

   Check if left.left matches right.right and left.right matches right.left recursively to confirm mirror symmetry.

3. Final Answer:

   Compare left subtree with right subtree by recursively checking if left.left matches right.right and left.right matches right.left -> Option D

4. Quick Check:

   Symmetry = recursive mirror check [OK]

Hint: Symmetry means left subtree mirrors right subtree recursively [OK]

Common Mistakes:

• Only comparing node counts, not structure
• Comparing node values without structure
• Using traversal orders that don't check mirror