Tree Traversal Postorder Left Right Root in DSA Typescript

Mental Model

Visit the left side first, then the right side, and finally the root node last.

Analogy: Imagine cleaning a room by first tidying the left corner, then the right corner, and only after both are clean, you clean the center of the room.

    1
   / \
  2   3
 / \
4   5
↑ root

Dry Run Walkthrough

Input: Tree: 1 with left child 2 and right child 3; 2 has children 4 (left) and 5 (right)

Goal: Print nodes in postorder: left subtree, right subtree, then root

Step 1: Traverse left subtree of root (1) to node 2

Visiting node 2 -> left child 4 and right child 5

Why: We must visit left subtree before root

Step 2: Traverse left subtree of node 2 to node 4

At node 4 with no children

Why: Left subtree of 2 is 4, visit it first

Step 3: Visit node 4 (leaf), print 4

Output so far: 4

Why: No children, so print node

Step 4: Traverse right subtree of node 2 to node 5

At node 5 with no children

Why: After left subtree, visit right subtree

Step 5: Visit node 5 (leaf), print 5

Output so far: 4 5

Why: No children, so print node

Step 6: Visit node 2 (after left and right subtrees), print 2

Output so far: 4 5 2

Why: Root printed after children

Step 7: Traverse right subtree of root (1) to node 3

At node 3 with no children

Why: After left subtree, visit right subtree

Step 8: Visit node 3 (leaf), print 3

Output so far: 4 5 2 3

Why: No children, so print node

Step 9: Visit root node 1 (after left and right subtrees), print 1

Output so far: 4 5 2 3 1

Why: Root printed last

Result:

4 5 2 3 1

Annotated Code

DSA Typescript

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 postorderTraversal(root: TreeNode | null, result: number[] = []): number[] {
  if (root === null) return result; // base case: empty node
  postorderTraversal(root.left, result); // traverse left subtree
  postorderTraversal(root.right, result); // traverse right subtree
  result.push(root.val); // visit root last
  return result;
}

// Driver code
const root = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3)
);
const output = postorderTraversal(root);
console.log(output.join(' '));

if (root === null) return result;

stop recursion at empty node

postorderTraversal(root.left, result);

traverse left subtree first

postorderTraversal(root.right, result);

then traverse right subtree

result.push(root.val);

visit root node last

Output

4 5 2 3 1

Complexity Analysis

Time: O(n) because each node is visited exactly once

Space: O(n) due to recursion stack in worst case and output storage

vs Alternative: Compared to preorder or inorder, postorder also visits all nodes once, so time is same; space depends on tree height

Edge Cases

Empty tree (root is null)

Returns empty list without error

DSA Typescript

if (root === null) return result;

Single node tree

Returns list with single node value

DSA Typescript

result.push(root.val);

Tree with only left children

Traverses down left side and prints nodes bottom-up

DSA Typescript

postorderTraversal(root.left, result);

When to Use This Pattern

When you need to process children before the parent, especially for deleting or evaluating expressions, use postorder traversal.

Common Mistakes

Mistake: Visiting root before children (preorder) instead of after
Fix: Move the root visit (push) after traversing left and right subtrees

Mistake: Forgetting to check for null nodes causing errors
Fix: Add base case to return when node is null

Summary

Visits left subtree, then right subtree, then the root node last.

Use when you need to process children before their parent, like in expression evaluation or tree deletion.

The root is visited only after all its children have been visited.

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: Match the traversal order to options

   Left subtree, Right subtree, Root node correctly lists Left subtree, Right subtree, Root node order.

3. Final Answer:

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

4. Quick Check:

   Postorder = Left, Right, Root [OK]

Hint: Remember: postorder ends with root after children [OK]

Common Mistakes:

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

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

easy

A. function postorder(node: TreeNode | null): TreeNode[]

B. function postorder(node: TreeNode): number

C. function postorder(): TreeNode

D. function postorder(node: TreeNode | null): void

Solution

1. Step 1: Identify correct parameter and return type for traversal

   Traversal functions usually take a node or null and return void if printing or processing inline.

2. Step 2: Check options for correct signature

   function postorder(node: TreeNode | null): void takes a node or null and returns void, suitable for traversal printing or processing.

3. Final Answer:

   function postorder(node: TreeNode | null): void -> Option D

4. Quick Check:

   Traversal function signature = function postorder(node: TreeNode | null): void [OK]

Hint: Traversal usually takes node|null and returns void [OK]

Common Mistakes:

• Omitting null in parameter type
• Returning incorrect types like TreeNode or number
• Missing parameter in function signature

3. Given the following binary tree:

    1
   / \
  2   3
 / \
4   5

What is the output of a postorder traversal?

medium

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

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

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

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

Solution

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

   Left subtree rooted at 2: postorder visits 4, then 5, then 2.

2. Step 2: Traverse right subtree and root

   Right subtree is 3, visited next. Finally, root 1 is visited.

3. Final Answer:

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

4. Quick Check:

   Postorder output = [4, 5, 2, 3, 1] [OK]

Hint: Postorder prints children before parent [OK]

Common Mistakes:

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

4. Consider this TypeScript postorder traversal function:

function postorder(node: TreeNode | null): void {
  if (!node) return;
  postorder(node.right);
  postorder(node.left);
  console.log(node.val);
}

What is the error in this code?

medium

A. It prints node value before children

B. It does not check for null nodes

C. It visits right subtree before left, reversing postorder

D. It returns a value but should be void

Solution

1. Step 1: Analyze traversal order in code

   The function calls postorder on right child first, then left child, then prints root.

2. Step 2: Compare with correct postorder order

   Correct postorder is left, right, root. This code reverses left and right order.

3. Final Answer:

   It visits right subtree before left, reversing postorder -> Option C

4. Quick Check:

   Left before right in postorder [OK]

Hint: Postorder = left first, then right, then root [OK]

Common Mistakes:

• Swapping left and right subtree calls
• Printing before visiting children
• Ignoring null checks

5. You want to collect all node values of a binary tree in postorder traversal into an array using TypeScript. Which code snippet correctly implements this?

hard

A. function postorder(node: TreeNode | null, result: number[]): void {
if (!node) return;
result.push(node.val);
postorder(node.left, result);
postorder(node.right, result);
}

B. function postorder(node: TreeNode | null, result: number[]): void {
if (!node) return;
postorder(node.left, result);
postorder(node.right, result);
result.push(node.val);
}

C. function postorder(node: TreeNode | null, result: number[]): number[] {
if (!node) return result;
result.push(node.val);
postorder(node.left, result);
postorder(node.right, result);
return result;
}

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

Solution

1. Step 1: Understand postorder traversal collection

   Postorder visits left, then right, then root. Values should be pushed after children.

2. Step 2: Check each option for correct order and pushing

   function postorder(node: TreeNode | null, result: number[]): void { if (!node) return; postorder(node.left, result); postorder(node.right, result); result.push(node.val); } visits left, right, then pushes node value, correctly collecting postorder.

3. Final Answer:

   function postorder(node: TreeNode | null, result: number[]): void { if (!node) return; postorder(node.left, result); postorder(node.right, result); result.push(node.val); } -> Option B

4. Quick Check:

   Push after children = postorder [OK]

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

Common Mistakes:

• Pushing node value before children
• Returning new arrays instead of using passed array
• Swapping left and right subtree calls