Binary Tree Postorder Traversal

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 the order: left subtree → right subtree → current node. This means we process all children before processing the parent node.

Note: You may implement this using either recursive or iterative approaches.

Input & Output

Example 1 — Basic Tree

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

› Output: [3,2,1]

💡 Note: Postorder visits left→right→root: node 3 (leaf), then node 2, finally root 1

Example 2 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree returns empty array

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Single node tree: only root to process

Constraints

The number of nodes in the tree is in the range [0, 100]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

Binary tree postorder traversal visits nodes in left→right→root order. The recursive approach naturally follows this pattern, while the iterative approach uses a stack with result reversal. Best approach: Recursive for simplicity. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Iterative with Stack

⏱️ Time: O(n) Space: O(h)

Use two stacks or reverse the result to achieve postorder without recursion. Process nodes in reverse postorder (root→right→left) then reverse the final result.

Recursive Postorder

⏱️ Time: O(n) Space: O(h)

Use recursion to naturally handle the postorder sequence. For each node, recursively visit left subtree, then right subtree, then add current node's value to result.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int result[1000];
int resultSize;

void postorder(struct TreeNode* node) {
    if (!node) {
        return;
    }
    postorder(node->left);
    postorder(node->right);
    result[resultSize++] = node->val;
}

int* solution(struct TreeNode* root, int* returnSize) {
    resultSize = 0;
    postorder(root);
    *returnSize = resultSize;
    return result;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -101) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -101) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -101) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array - simple parsing for integers and null
    int arr[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    
    while (token != NULL && size < 1000) {
        if (strncmp(token, "null", 4) == 0) {
            arr[size] = -101; // Use -101 as null marker (outside constraint range)
        } else {
            arr[size] = atoi(token);
        }
        size++;
        token = strtok(NULL, "[],\n ");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    int returnSize;
    int* result = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

4.2K 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