Binary Tree Level Order Traversal II

Binary Tree Level Order Traversal II - Problem

Given the root of a binary tree, return the bottom-up level order traversal of its nodes' values. This means traversing from left to right, level by level from leaf to root.

In other words, collect all nodes at each level, but return the levels in reverse order - starting from the deepest level and ending at the root level.

For example, if a tree has 3 levels, return the nodes in order: Level 3 → Level 2 → Level 1

Input & Output

Example 1 — Basic Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: [[15,7],[9,20],[3]]

💡 Note: Level order traversal gives [[3],[9,20],[15,7]]. Reversing gives [[15,7],[9,20],[3]] for bottom-up order.

Example 2 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Tree has only one level with one node. Result is [[1]].

Example 3 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree returns empty result.

Constraints

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

Visualization

Tap to expand

Asked in

A Amazon 42 M Microsoft 35 F Facebook 28 🍎 Apple 22

The key insight is that bottom-up level order traversal is just regular level-order traversal with the levels reversed. Best approach is BFS with queue to collect levels naturally, then reverse the result. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ Dfs

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

BFS Level Order + Reverse

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

Perform standard BFS level-order traversal using a queue, collecting nodes level by level. Store each level in a separate array, then reverse the final list of levels to get bottom-up order.

DFS with Level Tracking

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

Traverse the tree using DFS while tracking the current level. Store nodes in a list of lists where each inner list represents a level. Finally reverse the order of levels.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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;
}

static int result[1000][1000];
static int levelSizes[1000];
static int numLevels;

void solution(struct TreeNode* root) {
    numLevels = 0;
    if (!root) return;
    
    // BFS using queue
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        levelSizes[numLevels] = levelSize;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            result[numLevels][i] = node->val;
            
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
        numLevels++;
    }
}

struct TreeNode* buildTree(char* s) {
    if (!s || strlen(s) < 3) return NULL;
    
    // Parse array string like "[1,2,3,null,null,4,5]"
    char* tokens[1000];
    int tokenCount = 0;
    
    // Make a copy to avoid modifying original string
    char* str_copy = malloc(strlen(s) + 1);
    strcpy(str_copy, s);
    
    // Skip opening bracket
    char* ptr = str_copy + 1;
    char* token = strtok(ptr, ",]");
    
    while (token && tokenCount < 1000) {
        // Remove whitespace
        while (isspace(*token)) token++;
        tokens[tokenCount++] = token;
        token = strtok(NULL, ",]");
    }
    
    if (tokenCount == 0 || strcmp(tokens[0], "null") == 0) {
        free(str_copy);
        return NULL;
    }
    
    struct TreeNode* root = createNode(atoi(tokens[0]));
    struct TreeNode* queue[1000];
    int front = 0, rear = 1;
    queue[0] = root;
    
    int i = 1;
    while (front < rear && i < tokenCount) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->left = createNode(atoi(tokens[i]));
            queue[rear++] = node->left;
        }
        i++;
        
        // Right child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->right = createNode(atoi(tokens[i]));
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(str_copy);
    return root;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    struct TreeNode* root = buildTree(input);
    solution(root);
    
    // Output in bottom-up order (reverse levels)
    printf("[");
    for (int level = numLevels - 1; level >= 0; level--) {
        if (level < numLevels - 1) printf(",");
        printf("[");
        for (int i = 0; i < levelSizes[level]; i++) {
            if (i > 0) printf(",");
            printf("%d", result[level][i]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.8K Views

Medium Frequency

~15 min Avg. Time

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