Binary Tree Postorder Traversal - Practice Coding Problems

Binary Tree Postorder Traversal - Problem

Given the root of a binary tree, return the postorder traversal of its nodes' values.

In postorder traversal, we visit nodes in this specific order:

Left subtree first
Right subtree second
Current node last

This traversal pattern is particularly useful for operations like deleting nodes, calculating directory sizes, or evaluating expression trees where you need to process children before their parent.

Example: For a tree with root 1, left child 2, and right child 3, the postorder traversal would be [2, 3, 1] - we visit the left child (2), then right child (3), and finally the root (1).

Input & Output

example_1.py — Basic Tree

$ Input: root = [1,null,2,3]

› Output: [3,2,1]

💡 Note: The tree has root 1 with right child 2, and 2 has left child 3. Postorder visits: left subtree of 2 (which is 3), then right subtree of 2 (empty), then 2 itself, finally root 1.

example_2.py — Empty Tree

$ Input: root = []

› Output: []

💡 Note: An empty tree has no nodes to traverse, so the result is an empty list.

example_3.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: A tree with only one node. Since there are no children to visit first, we simply return the root node's value.

Visualization

Tap to expand

Understanding the Visualization

Start from Bottom

Begin with the lowest level rooms (leaf nodes) since they have no dependencies

Work Your Way Up

Clean each floor only after all floors below it are completely clean

Finish at the Top

The executive office (root) is cleaned last, after all other floors are done

Key Takeaway

🎯 Key Insight: Postorder traversal processes children before parents, like cleaning dependencies first. Use a stack to track visiting order and ensure proper sequence!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once

✓ Linear Growth

Space Complexity

O(h + n)

Stack space O(h) for tree height plus O(n) for visited set

⚡ Linearithmic Space

Constraints

The number of the nodes in the tree is in the range [0, 100]
-100 <= Node.val <= 100
Follow up: Recursive solution is trivial, could you do it iteratively?

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses an iterative approach with a stack to achieve O(n) time complexity. The key insight is to use either a visited set to track processed children or a two-stack technique where the first stack creates a modified preorder (root-right-left) and the second stack reverses it to postorder (left-right-root). Both approaches visit each node exactly once, making them significantly more efficient than naive recursive implementations.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative with Stack (Optimal)	O(n)	O(h + n)	Use a stack to simulate recursion and track visited nodes for postorder traversal
Naive Recursive (Multiple Passes)	O(n²)	O(h)	Recursively check if left and right subtrees are processed before processing current node

Iterative with Stack (Optimal) — Algorithm Steps

Initialize a stack with root and an empty result list
Use a visited set to track processed nodes
Pop from stack, if children exist and not visited, push back with children
If no unvisited children, add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Push root to stack, create visited set

Process

Check top of stack - if children not visited, push them

Complete

When node's children are done, add node to result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    // Count nodes first
    int totalNodes = countNodes(root);
    int* result = (int*)malloc(totalNodes * sizeof(int));
    
    // Use two arrays to simulate stacks
    struct TreeNode** stack1 = (struct TreeNode**)malloc(totalNodes * sizeof(struct TreeNode*));
    struct TreeNode** stack2 = (struct TreeNode**)malloc(totalNodes * sizeof(struct TreeNode*));
    int top1 = 0, top2 = 0;
    
    // Two-stack approach
    stack1[top1++] = root;
    
    while (top1 > 0) {
        struct TreeNode* node = stack1[--top1];
        stack2[top2++] = node;
        
        if (node->left) stack1[top1++] = node->left;
        if (node->right) stack1[top1++] = node->right;
    }
    
    while (top2 > 0) {
        result[(*returnSize)++] = stack2[--top2]->val;
    }
    
    free(stack1);
    free(stack2);
    return result;
}

int countNodes(struct TreeNode* root) {
    if (!root) return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once

✓ Linear Growth

Space Complexity

O(h + n)

Stack space O(h) for tree height plus O(n) for visited set

⚡ Linearithmic Space

Constraints

The number of the nodes in the tree is in the range [0, 100]
-100 <= Node.val <= 100
Follow up: Recursive solution is trivial, could you do it iteratively?

125.0K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Iterative with Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler