Tree Traversal Postorder Left Right Root in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the order of visiting nodes in Postorder Tree Traversal?

In Postorder traversal, nodes are visited in this order: Left subtree, then Right subtree, and finally the Root node.

intermediate

Why is Postorder traversal useful in deleting a tree?

Postorder visits children before the parent, so it ensures all child nodes are deleted before the parent node, preventing dangling references.

beginner

Show the Postorder traversal output for this tree:
Root=1, Left=2, Right=3

The Postorder traversal visits Left (2), Right (3), then Root (1). So output is: 2 -> 3 -> 1

intermediate

What is the difference between Inorder and Postorder traversal?

Inorder visits Left, Root, Right. Postorder visits Left, Right, Root. Postorder always visits the root last.

beginner

Write the recursive steps for Postorder traversal.

1. Traverse left subtree recursively.
2. Traverse right subtree recursively.
3. Visit the root node.

In Postorder traversal, which node is visited last?

A Left child

B Right child

C Root node

D None of the above

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

What is the Postorder traversal of a tree with root 5, left child 3, and right child 7?

A 3 -> 7 -> 5

B 5 -> 3 -> 7

C 7 -> 3 -> 5

D 3 -> 5 -> 7

Postorder visits left (3), right (7), then root (5).

Which traversal order is best for deleting all nodes in a tree safely?

A Preorder

B Inorder

C Level order

D Postorder

Postorder visits children before the parent, so it is safe for deletion.

In Postorder traversal, what is the first step?

A Visit root node

B Traverse left subtree

C Traverse right subtree

D Traverse both subtrees simultaneously

Postorder starts by traversing the left subtree.

Which of these is NOT a valid Postorder traversal sequence for the tree Root=1, Left=2, Right=3?

A 1 -> 2 -> 3

B 3 -> 2 -> 1

C 2 -> 3 -> 1

D 2 -> 1 -> 3

Postorder always visits root last, so '1 -> 2 -> 3' is preorder, not postorder.

Explain the steps of Postorder traversal and why the root node is visited last.

Think about visiting children before the parent.

Describe a real-life scenario where Postorder traversal is useful.

Consider tasks that require finishing smaller parts before the whole.

Practice

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

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 nodes in the order: left subtree first, then right subtree, and finally the root node.

2. Step 2: Match the traversal order to options

   Left subtree, Right subtree, Root node correctly lists the order as Left, Right, Root which matches postorder traversal.

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
• Swapping left and right subtree order
• Thinking root is visited first

2. Which of the following C++ function signatures correctly represents a postorder traversal of a binary tree node Node*?

easy

A. void postorder(Node* root) { visit(root); postorder(root->left); postorder(root->right); }

B. void postorder(Node* root) { postorder(root->right); postorder(root->left); visit(root); }

C. void postorder(Node* root) { postorder(root->right); visit(root); postorder(root->left); }

D. void postorder(Node* root) { postorder(root->left); postorder(root->right); visit(root); }

Solution

1. Step 1: Recall postorder traversal steps

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

2. Step 2: Check function calls order

   void postorder(Node* root) { postorder(root->left); postorder(root->right); visit(root); } calls postorder on left, then right, then visits root, matching postorder traversal.

3. Final Answer:

   void postorder(Node* root) { postorder(root->left); postorder(root->right); visit(root); } -> Option D

4. Quick Check:

   Left, Right, Root call order = void postorder(Node* root) { postorder(root->left); postorder(root->right); visit(root); } [OK]

Hint: Postorder calls left, then right, then root visit [OK]

Common Mistakes:

• Visiting root before children (preorder)
• Swapping left and right subtree calls
• Missing visit call after recursion

3. Given the binary tree:

    1
   / \
  2   3
 / \
4   5

What is the output of a postorder traversal?

medium

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

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

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

D. [2, 4, 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 alone, visited next. Finally, root 1 is visited.

3. Final Answer:

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

4. Quick Check:

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

Hint: Visit children fully before root [OK]

Common Mistakes:

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

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

void postorder(Node* root) {
  if (!root) return;
  postorder(root->right);
  postorder(root->left);
  visit(root);
}

medium

A. Left and right subtree calls are swapped

B. The base case check is incorrect

C. The visit call is missing

D. The function should visit root before children

Solution

1. Step 1: Analyze recursive calls order

   The code calls postorder on right subtree first, then left subtree, which reverses the correct order.

2. Step 2: Understand correct postorder order

   Postorder requires left subtree first, then right subtree, then root visit.

3. Final Answer:

   Left and right subtree calls are swapped -> Option A

4. Quick Check:

   Left before right in postorder [OK]

Hint: Left subtree call must come before right [OK]

Common Mistakes:

• Swapping left and right subtree calls
• Visiting root before children
• Omitting base case check

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

hard

A. void postorder(Node* root, vector<int>& res) { if (!root) return; res.push_back(root->val); postorder(root->left, res); postorder(root->right, res); }

B. void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->left, res); postorder(root->right, res); res.push_back(root->val); }

C. void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->right, res); postorder(root->left, res); res.push_back(root->val); }

D. void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->left, res); res.push_back(root->val); postorder(root->right, res); }

Solution

1. Step 1: Confirm traversal order in code

   void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->left, res); postorder(root->right, res); res.push_back(root->val); } calls postorder on left, then right subtree, then adds root value to vector, matching postorder.

2. Step 2: Check other options for order mistakes

   The other options either add the root value too early or swap left and right calls, breaking postorder.

3. Final Answer:

   void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->left, res); postorder(root->right, res); res.push_back(root->val); } -> Option B

4. Quick Check:

   Left, Right, Root push_back order = void postorder(Node* root, vector<int>& res) { if (!root) return; postorder(root->left, res); postorder(root->right, res); res.push_back(root->val); } [OK]

Hint: Push root value after left and right recursion [OK]

Common Mistakes:

• Pushing root value before children
• Swapping left and right subtree calls
• Forgetting to check for null root