Mirror a Binary Tree in DSA C++ - Execution Trace

Concept Flow - Mirror a Binary Tree

Start at root node

↓

Swap left and right child

↓

Recursively mirror left subtree

↓

Recursively mirror right subtree

↓

Return mirrored subtree

Start at the root, swap its left and right children, then do the same for each subtree recursively until all nodes are processed.

Execution Sample

DSA C++

void mirror(Node* root) {
  if (!root) return;
  swap(root->left, root->right);
  mirror(root->left);
  mirror(root->right);
}

This code swaps left and right children of each node recursively to create the mirror image of the binary tree.

Execution Table

Step	Operation	Node Visited	Pointer Changes	Tree State
1	Start at root	1	None	1 / \ 2 3
2	Swap children	1	left=3, right=2	1 / \ 3 2
3	Recurse left subtree	3	None	3 / \ 6 7
4	Swap children	3	left=7, right=6	3 / \ 7 6
5	Recurse left subtree	7	None	7 (leaf)
6	Recurse right subtree	6	None	6 (leaf)
7	Recurse right subtree of root	2	None	2 / \ 4 5
8	Swap children	2	left=5, right=4	2 / \ 5 4
9	Recurse left subtree	5	None	5 (leaf)
10	Recurse right subtree	4	None	4 (leaf)
11	Return to root	1	None	1 / \ 3 2 / \ / \ 7 6 5 4

💡 All nodes visited and children swapped, tree is fully mirrored.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 8	Final
root	Node 1	Node 1	Node 1	Node 1	Node 1
current node	Node 1	Node 3	Node 7	Node 2	Node 1
left child of current	Node 2	Node 7	None	Node 5	Node 3
right child of current	Node 3	Node 6	None	Node 4	Node 2
tree structure	1->2,3; 2->4,5; 3->6,7	1->3,2; 3->7,6; 2->4,5	3->7,6; 7 leaf; 6 leaf	2->5,4; 5 leaf; 4 leaf	1->3,2; 3->7,6; 2->5,4

Key Moments - 3 Insights

Why do we swap children before recursive calls?

Swapping children first (see Step 2) ensures that when recursion goes to left and right subtrees, it processes the new mirrored positions, correctly flipping the whole tree.

What happens when a node is a leaf?

At leaf nodes (Steps 5, 6, 9, 10), there are no children to swap, so recursion returns immediately, stopping further calls.

Why do we check if the node is null at the start?

The base case (Step 1) prevents recursion on empty nodes, avoiding errors and stopping recursion when reaching beyond leaves.

Visual Quiz - 3 Questions

Look at the execution table, what is the left child of node 1 after Step 2?

A Node 2

B Node 3

C Node 4

D Node 5

💡 Hint

Check the 'Pointer Changes' and 'Tree State' columns at Step 2.

At which step does the recursion visit node 7?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look at the 'Node Visited' column to find when node 7 is processed.

If we skip swapping children at each node, how would the final tree state change?

A Tree becomes empty

B Only leaf nodes swap

C Tree remains unchanged

D Tree becomes a linked list

💡 Hint

Refer to the 'Operation' column and understand the role of swapping in mirroring.

Concept Snapshot

Mirror a Binary Tree:
- Swap left and right child of each node
- Recursively apply to left and right subtrees
- Base case: if node is null, return
- Result: tree flipped around its root
- Common use: image reflection, tree transformations

Full Transcript

To mirror a binary tree, start at the root node. Swap its left and right children. Then recursively do the same for the left subtree and the right subtree. If a node is null, stop recursion. This process flips the tree around its root, creating a mirror image. The code swaps children first, then recurses, ensuring the entire tree is mirrored correctly. Leaf nodes have no children to swap, so recursion ends there. This method is simple and effective for tree transformations.