Mirror a Binary Tree in DSA Typescript - Execution Trace

Concept Flow - Mirror a Binary Tree

Start at root node

↓

Swap left and right children

↓

Recursively mirror left subtree

↓

Recursively mirror right subtree

↓

Return mirrored subtree

↓

Done when all nodes processed

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

Execution Sample

DSA Typescript

function mirror(node: TreeNode | null): TreeNode | null {
  if (!node) return null;
  [node.left, node.right] = [mirror(node.right), mirror(node.left)];
  return node;
}

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

Execution Table

Step	Operation	Node Visited	Pointer Changes	Tree State (Visual)
1	Start at root	1	None	1 / \ 2 3 / \ \ 4 5 6
2	Swap children of node 1	1	left <-> right swapped	1 / \ 3 2 / / \ 6 4 5
3	Mirror left subtree of node 1 (node 3)	3	None yet	1 / \ 3 2 / / \ 6 4 5
4	Swap children of node 3	3	left <-> right swapped	1 / \ 3 2 \ / \ 6 4 5
5	Mirror left subtree of node 3 (null)	null	None	1 / \ 3 2 \ / \ 6 4 5
6	Mirror right subtree of node 3 (node 6)	6	None	1 / \ 3 2 \ / \ 6 4 5
7	Swap children of node 6	6	left <-> right swapped (both null)	1 / \ 3 2 \ / \ 6 4 5
8	Mirror left subtree of node 6 (null)	null	None	1 / \ 3 2 \ / \ 6 4 5
9	Mirror right subtree of node 6 (null)	null	None	1 / \ 3 2 \ / \ 6 4 5
10	Mirror right subtree of node 1 (node 2)	2	None yet	1 / \ 3 2 \ / \ 6 4 5
11	Swap children of node 2	2	left <-> right swapped	1 / \ 3 2 \ / \ 6 5 4
12	Mirror left subtree of node 2 (node 5)	5	None	1 / \ 3 2 \ / \ 6 5 4
13	Swap children of node 5	5	left <-> right swapped (both null)	1 / \ 3 2 \ / \ 6 5 4
14	Mirror left subtree of node 5 (null)	null	None	1 / \ 3 2 \ / \ 6 5 4
15	Mirror right subtree of node 5 (null)	null	None	1 / \ 3 2 \ / \ 6 5 4
16	Mirror right subtree of node 2 (node 4)	4	None	1 / \ 3 2 \ / \ 6 5 4
17	Swap children of node 4	4	left <-> right swapped (both null)	1 / \ 3 2 \ / \ 6 5 4
18	Mirror left subtree of node 4 (null)	null	None	1 / \ 3 2 \ / \ 6 5 4
19	Mirror right subtree of node 4 (null)	null	None	1 / \ 3 2 \ / \ 6 5 4
20	All nodes processed, return mirrored tree	null	None	1 / \ 3 2 \ / \ 6 5 4

💡 All nodes visited and their children swapped, recursion ends.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 7	After Step 11	After Step 17	Final
node	1 (root)	1	3 (left child of root)	6 (left child of 3)	2 (right child of root)	4 (right child of 2)	null (end)
left child	2	3	null	null	5	null	null
right child	3	2	6	null	4	null	null

Key Moments - 3 Insights

Why do we swap children before recursively calling mirror on subtrees?

Swapping first ensures that when recursion goes down, it mirrors the correct new left and right subtrees. See execution_table steps 2 and 4 where swap happens before recursive calls.

What happens when a node is null?

The function returns immediately without changes, as shown in steps 5, 8, 9, 14, 15, 18, 19 where null nodes cause no action.

Why does the tree structure change visually after each swap?

Because swapping left and right pointers changes the physical layout of the tree, as seen in the Tree State column after steps 2, 4, and 11.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what change happens to node 1?

A Its left and right children are swapped

B Its children are set to null

C It is deleted

D No change

💡 Hint

Check the Pointer Changes and Tree State columns at step 2.

At which step does the function process node 6?

A Step 4

B Step 6

C Step 11

D Step 17

💡 Hint

Look for 'Node Visited' column in execution_table.

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

A The tree would be fully mirrored

B The tree would be empty

C The tree would remain unchanged

D Only leaf nodes would swap

💡 Hint

Refer to the concept_flow and execution_table steps where swapping is key.

Concept Snapshot

Mirror a Binary Tree:
- Swap left and right children of each node
- Do this recursively for all nodes
- Base case: if node is null, return
- Result: tree structure flipped horizontally
- Use recursion to handle all subtrees

Full Transcript

To mirror a binary tree, start at the root node. Swap its left and right children pointers. Then recursively do the same for the left subtree and the right subtree. If a node is null, return immediately. This process flips the tree horizontally. The code swaps children first, then calls mirror recursively on the swapped children. The recursion ends when all nodes have been processed. The tree's visual structure changes after each swap, showing the mirror effect.

Practice

1. What does it mean to mirror a binary tree?

easy

A. Swap the left and right children of every node in the tree

B. Remove all leaf nodes from the tree

C. Convert the tree into a linked list

D. Sort the tree 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.

2. Step 2: Effect on the tree structure

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

3. Final Answer:

   Swap the left and right children of every node in the tree -> Option A

4. Quick Check:

   Mirror = Swap children [OK]

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

Common Mistakes:

• Thinking mirror means sorting nodes
• Confusing mirror with removing nodes
• Assuming mirror changes node values

2. Which of the following TypeScript function signatures correctly represents a function to mirror a binary tree node?

easy

A. function mirrorTree(root: string): string

B. function mirrorTree(root: number): number

C. function mirrorTree(root: TreeNode): void

D. function mirrorTree(root: TreeNode | null): TreeNode | null

Solution

1. Step 1: Identify the input and output types

   The function should accept a TreeNode or null and return a TreeNode or null after mirroring.

2. Step 2: Check each option's signature

   function mirrorTree(root: TreeNode | null): TreeNode | null matches the expected input and output types for a binary tree mirror function.

3. Final Answer:

   function mirrorTree(root: TreeNode | null): TreeNode | null -> Option D

4. Quick Check:

   Correct signature uses TreeNode or null [OK]

Hint: Mirror function inputs and outputs TreeNode or null [OK]

Common Mistakes:

• Using primitive types like number or string instead of TreeNode
• Returning void instead of the mirrored tree
• Not allowing null as input

3. Given the following TypeScript code, what is the output when the tree is mirrored and then printed in preorder?

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val: number, left: TreeNode | null = null, right: TreeNode | null = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function mirrorTree(root: TreeNode | null): TreeNode | null {
  if (!root) return null;
  const left = mirrorTree(root.left);
  const right = mirrorTree(root.right);
  root.left = right;
  root.right = left;
  return root;
}

function preorder(root: TreeNode | null): number[] {
  if (!root) return [];
  return [root.val, ...preorder(root.left), ...preorder(root.right)];
}

const tree = new TreeNode(1, new TreeNode(2, new TreeNode(4), new TreeNode(5)), new TreeNode(3));
const mirrored = mirrorTree(tree);
console.log(preorder(mirrored));

medium

A. [1, 2, 4, 5, 3]

B. [1, 3, 2, 5, 4]

C. [1, 3, 5, 4, 2]

D. [1, 2, 5, 4, 3]

Solution

1. Step 1: Understand the original tree structure

   The tree is:
   1
   ├─ 2
   │ ├─ 4
   │ └─ 5
   └─ 3

2. Step 2: Mirror the tree by swapping left and right children

   After mirroring:
   1
   ├─ 3
   └─ 2
   ├─ 5
   └─ 4

3. Step 3: Preorder traversal of mirrored tree

   Preorder visits root, left, right:
   1, 3, 2, 5, 4

4. Final Answer:

   [1, 3, 2, 5, 4] -> Option B

5. Quick Check:

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

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

Common Mistakes:

• Not swapping children correctly
• Confusing preorder with inorder or postorder
• Forgetting to mirror recursively

4. The following TypeScript function is intended to mirror a binary tree but contains a bug. What is the bug?

function mirrorTree(root: TreeNode | null): TreeNode | null {
  if (!root) return null;
  mirrorTree(root.left);
  mirrorTree(root.right);
  const temp = root.left;
  root.left = root.right;
  root.right = temp;
  return root;
}

medium

A. The base case should return root instead of null

B. The swapping of left and right children is done before recursion

C. The recursive calls do not assign the mirrored subtrees back to root.left and root.right

D. The function does not handle empty trees

Solution

1. Step 1: Analyze the recursive calls

   The function calls mirrorTree on root.left and root.right but does not assign the results back to root.left and root.right.

2. Step 2: Understand the effect of missing assignments

   Without assigning, the subtrees are not updated with their mirrored versions, so the mirror is incomplete.

3. Final Answer:

   The recursive calls do not assign the mirrored subtrees back to root.left and root.right -> Option C

4. Quick Check:

   Assign recursive results to children [OK]

Hint: Always assign recursive mirror results back to children [OK]

Common Mistakes:

• Ignoring return values of recursive calls
• Swapping children before recursion
• Incorrect base case handling

5. You have a binary tree where some nodes have only one child (either left or right). After mirroring the tree using the standard mirror function, which of the following statements is true about the structure of the mirrored tree?

hard

A. Nodes with only left child will have only right child after mirroring

B. Nodes with only left child will have no children after mirroring

C. Nodes with only right child will have both children after mirroring

D. The tree structure remains unchanged after mirroring

Solution

1. Step 1: Understand mirroring effect on single-child nodes

   Mirroring swaps left and right children of every node.

2. Step 2: Effect on nodes with only one child

   If a node has only a left child, after mirroring, that child becomes the right child, and left becomes null.

3. Final Answer:

   Nodes with only left child will have only right child after mirroring -> Option A

4. Quick Check:

   Mirror swaps children, single left child becomes right [OK]

Hint: Mirror swaps children, single left child moves to right [OK]

Common Mistakes:

• Assuming children disappear after mirroring
• Thinking mirroring adds children
• Believing tree structure stays same