Tree Traversal Postorder Left Right Root in DSA C# - Time & Space Complexity

Time Complexity: Tree Traversal Postorder Left Right Root

O(n)

Understanding Time Complexity

We want to understand how long it takes to visit all nodes in a tree using postorder traversal.

How does the time grow as the tree gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class TreeNode {
    public int val;
    public TreeNode left, right;
    public TreeNode(int val=0) { this.val = val; }
}

void Postorder(TreeNode node) {
    if (node == null) return;
    Postorder(node.left);
    Postorder(node.right);
    Console.WriteLine(node.val);
}
    

This code visits each node in the tree after visiting its left and right children.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls visiting each node once.
• How many times: Once per node in the tree.

How Execution Grows With Input

Each node is visited exactly once, so the work grows directly with the number of nodes.

Input Size (n)	Approx. Operations
10	About 10 visits
100	About 100 visits
1000	About 1000 visits

Pattern observation: The time grows linearly as the tree size increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the traversal grows in direct proportion to the number of nodes.

Common Mistake

[X] Wrong: "Postorder traversal takes more than linear time because it visits nodes multiple times."

[OK] Correct: Each node is visited exactly once, even though recursion happens multiple times, so total work is linear.

Interview Connect

Understanding traversal time helps you explain how tree algorithms scale and shows you can analyze recursive code clearly.

Self-Check

"What if we changed the traversal to visit nodes in preorder (root left right)? How would the time complexity change?"

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