Tree Traversal Postorder Left Right Root in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this postorder traversal?

Given the binary tree below, what is the output of the postorder traversal (Left, Right, Root)?

DSA C#

class Node {
    public int Value;
    public Node Left, Right;
    public Node(int val) { Value = val; Left = Right = null; }
}

// Tree structure:
//       1
//      / \
//     2   3
//    / \
//   4   5

void Postorder(Node root) {
    if (root == null) return;
    Postorder(root.Left);
    Postorder(root.Right);
    Console.Write(root.Value + " ");
}

// Call Postorder(root) where root is node with value 1

A 1 2 3 4 5

B 4 2 5 3 1

C 2 4 5 3 1

D 4 5 2 3 1

💡 Hint

Remember postorder visits left subtree, then right subtree, then the root node.

Postorder traversal visits nodes in Left, Right, Root order. For the given tree, it visits 4, then 5, then 2, then 3, then 1.

❓ Predict Output

intermediate

What is the postorder traversal output of this tree?

Consider the binary tree: // 10 // / \ // 20 30 // / \ // 40 50 What is the output of postorder traversal (Left, Right, Root)?

DSA C#

class Node {
    public int Value;
    public Node Left, Right;
    public Node(int val) { Value = val; Left = Right = null; }
}

void Postorder(Node root) {
    if (root == null) return;
    Postorder(root.Left);
    Postorder(root.Right);
    Console.Write(root.Value + " ");
}

// Call Postorder(root) where root is node with value 10

A 10 20 30 40 50

B 20 40 50 30 10

C 20 30 40 50 10

D 40 50 30 20 10

💡 Hint

Postorder visits left subtree first, then right subtree, then root.

Traverse left subtree (20), then right subtree (40, 50, 30), then root (10). So output is 20 40 50 30 10.

🔧 Debug

advanced

Why does this postorder traversal code cause a runtime error?

Examine the following code snippet for postorder traversal. Why does it cause a runtime error when run on a non-empty tree?

DSA C#

class Node {
    public int Value;
    public Node Left, Right;
    public Node(int val) { Value = val; Left = Right = null; }
}

void Postorder(Node root) {
    Postorder(root.Left);
    Postorder(root.Right);
    Console.Write(root.Value + " ");
}

// Called with a valid root node

A It causes a NullReferenceException because root.Value is accessed before checking if root is null.

B It causes no error and prints the postorder traversal correctly.

C It causes a compile-time error because the method is missing a return type.

D It causes a StackOverflowException because there is no base case to stop recursion.

💡 Hint

Check if the code handles the case when root is null before accessing its members.

The code does not check if root is null before accessing root.Left, root.Right, and root.Value. This causes a NullReferenceException at runtime.

🧠 Conceptual

advanced

Which traversal order matches postorder traversal?

Select the correct order of visiting nodes in postorder traversal of a binary tree.

A Left, Right, Root

B Left, Root, Right

C Root, Left, Right

D Right, Left, Root

💡 Hint

Postorder means visiting children before the parent.

Postorder traversal visits the left subtree first, then the right subtree, and finally the root node.

🚀 Application

expert

What is the postorder traversal output after inserting nodes in this order?

You insert nodes into a binary search tree in this order: 15, 10, 20, 8, 12, 17, 25. What is the postorder traversal output of the resulting tree?

DSA C#

class Node {
    public int Value;
    public Node Left, Right;
    public Node(int val) { Value = val; Left = Right = null; }
}

Node Insert(Node root, int val) {
    if (root == null) return new Node(val);
    if (val < root.Value) root.Left = Insert(root.Left, val);
    else root.Right = Insert(root.Right, val);
    return root;
}

void Postorder(Node root) {
    if (root == null) return;
    Postorder(root.Left);
    Postorder(root.Right);
    Console.Write(root.Value + " ");
}

// Build tree by inserting 15,10,20,8,12,17,25
// Then call Postorder(root)

A 10 8 12 25 17 20 15

B 15 10 8 12 20 17 25

C 8 12 10 17 25 20 15

D 8 10 12 17 20 25 15

💡 Hint

Build the BST step by step, then do postorder traversal (Left, Right, Root).

After inserting nodes, the BST structure is: 15 / \ 10 20 / \ / \ 8 12 17 25 Postorder visits left subtree (8,12,10), right subtree (17,25,20), then root (15).

Practice

1. What is the order of nodes visited in a postorder tree traversal?

easy

A. Left subtree, Right subtree, Root node

B. Root node, Left subtree, Right subtree

C. Root node, Right subtree, Left subtree

D. Right subtree, Left subtree, Root node

Solution

1. Step 1: Understand postorder traversal definition

   Postorder traversal visits the left subtree first, then the right subtree, and finally the root node.

2. Step 2: Confirm the visiting order

   This order ensures children nodes are processed before their parent node.

3. Final Answer:

   Left subtree, Right subtree, Root node -> Option A

4. Quick Check:

   Postorder = Left, Right, Root [OK]

Hint: Remember: postorder ends with the root node [OK]

Common Mistakes:

• Confusing postorder with preorder or inorder
• Visiting root node first instead of last
• Swapping left and right subtree order

2. Which of the following C# method signatures correctly represents a postorder traversal of a binary tree node named root?

easy

A. void PostorderTraversal(Node root) { PostorderTraversal(root.Right); PostorderTraversal(root.Left); Console.WriteLine(root.Value); }

B. void PostorderTraversal(Node root) { Console.WriteLine(root.Value); PostorderTraversal(root.Left); PostorderTraversal(root.Right); }

C. void PostorderTraversal(Node root) { PostorderTraversal(root.Left); PostorderTraversal(root.Right); Console.WriteLine(root.Value); }

D. void PostorderTraversal(Node root) { Console.WriteLine(root.Value); PostorderTraversal(root.Right); PostorderTraversal(root.Left); }

Solution

1. Step 1: Identify correct postorder call sequence

   Postorder traversal calls left subtree, then right subtree, then processes the root.

2. Step 2: Match method calls to postorder order

   void PostorderTraversal(Node root) { PostorderTraversal(root.Left); PostorderTraversal(root.Right); Console.WriteLine(root.Value); } calls left, then right, then prints root value, matching postorder traversal.

3. Final Answer:

   void PostorderTraversal(Node root) { PostorderTraversal(root.Left); PostorderTraversal(root.Right); Console.WriteLine(root.Value); } -> Option C

4. Quick Check:

   Left, Right, Root call order = void PostorderTraversal(Node root) { PostorderTraversal(root.Left); PostorderTraversal(root.Right); Console.WriteLine(root.Value); } [OK]

Hint: Postorder prints after left and right recursive calls [OK]

Common Mistakes:

• Printing root value before recursive calls
• Swapping left and right subtree calls
• Missing recursive calls for subtrees

3. Given the binary tree below, what is the output of a postorder traversal?

    1
   / \
  2   3
 / \
4   5

medium

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

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

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

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

Solution

1. Step 1: Traverse left subtree of root (1)

   Left subtree is rooted at 2, with children 4 and 5. Postorder visits 4, then 5, then 2.

2. Step 2: Traverse right subtree and root

   Right subtree is 3 (leaf), visited next. Finally, root 1 is visited last.

3. Final Answer:

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

4. Quick Check:

   Postorder = Left, Right, Root = [4,5,2,3,1] [OK]

Hint: Visit children fully before parent in postorder [OK]

Common Mistakes:

• Visiting root before children
• Swapping left and right subtree order
• Confusing preorder or inorder output

4. The following C# code attempts a postorder traversal but produces incorrect output. What is the error?

void Postorder(Node root) {
  if (root == null) return;
  Console.WriteLine(root.Value);
  Postorder(root.Left);
  Postorder(root.Right);
}

medium

A. The root value is printed before traversing subtrees

B. The base case for null root is missing

C. Left and right subtree calls are swapped

D. The method does not return any value

Solution

1. Step 1: Analyze the order of operations in code

   The code prints root value first, then traverses left and right subtrees.

2. Step 2: Compare with postorder traversal rules

   Postorder requires visiting left and right subtrees before printing root value.

3. Final Answer:

   Root value printed before subtrees traversal -> Option A

4. Quick Check:

   Postorder prints after children, not before [OK]

Hint: Print root after recursive calls for postorder [OK]

Common Mistakes:

• Printing root before recursive calls
• Ignoring null base case (though present here)
• Swapping left and right subtree calls

5. You want to collect all node values of a binary tree in postorder traversal into a list in C#. Which code snippet correctly implements this?

hard

A. void Postorder(Node root, List<int> result) { if(root == null) return; result.Add(root.Value); Postorder(root.Right, result); Postorder(root.Left, result); }

B. void Postorder(Node root, List<int> result) { if(root == null) return; result.Add(root.Value); Postorder(root.Left, result); Postorder(root.Right, result); }

C. void Postorder(Node root, List<int> result) { if(root == null) return; Postorder(root.Right, result); Postorder(root.Left, result); result.Add(root.Value); }

D. void Postorder(Node root, List<int> result) { if(root == null) return; Postorder(root.Left, result); Postorder(root.Right, result); result.Add(root.Value); }

Solution

1. Step 1: Confirm traversal order in code

   void Postorder(Node root, List<int> result) { if(root == null) return; Postorder(root.Left, result); Postorder(root.Right, result); result.Add(root.Value); } calls left subtree, then right subtree, then adds root value to list, matching postorder.

2. Step 2: Verify list collection logic

   Adding root value after recursive calls ensures correct postorder sequence in the list.

3. Final Answer:

   void Postorder(Node root, List<int> result) { if(root == null) return; Postorder(root.Left, result); Postorder(root.Right, result); result.Add(root.Value); } -> Option D

4. Quick Check:

   Left, Right, Root with Add after recursion [OK]

Hint: Add node value after left and right recursive calls [OK]

Common Mistakes:

• Adding root value before recursive calls
• Swapping left and right subtree calls
• Not handling null root properly