Binary Tree Level Order Traversal II - Practice Coding Problems

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 we traverse from left to right, level by level, but return the levels in reverse order - starting from the leaf level and ending at the root level.

Think of it like building a tree from the ground up - we want to see each floor of the tree, but starting from the bottom floor and working our way to the top!

Example: For a tree with root value 3, left child 9, and right child 20 (where 20 has children 15 and 7), we would return [[15,7], [9,20], [3]] - notice how the deepest level comes first.

Input & Output

example_1.py — Standard Binary Tree

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

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

💡 Note: The tree has 3 levels: Level 0 (root) contains [3], Level 1 contains [9,20], and Level 2 (deepest) contains [15,7]. Bottom-up traversal returns levels in reverse order: deepest first, root last.

example_2.py — Single Node Tree

$ Input: [1]

› Output: [[1]]

💡 Note: Tree has only one node (the root), so there's only one level. The bottom-up traversal returns a single level containing just the root value.

example_3.py — Empty Tree

$ Input: []

› Output: []

💡 Note: Empty tree has no nodes, so the traversal returns an empty list. This is an edge case that should be handled gracefully.

Visualization

Tap to expand

Understanding the Visualization

Start at Ground Floor

Begin BFS at root level, queue contains [3]

Visit Floor 1

Process children of root: queue becomes [9, 20]

Visit Floor 2

Process leaf level: queue becomes [15, 7]

Stack Reports

As we process each floor, we stack the reports with newest on top

Read Stack

Final result reads from top to bottom: [[15,7], [9,20], [3]]

Key Takeaway

🎯 Key Insight: BFS naturally processes levels top-to-bottom, but we want bottom-to-top output. By using a deque and prepending each level to the front, we reverse the order during construction rather than after completion, making the solution both elegant and efficient.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse the tree h times (once for each level), and each traversal visits all n nodes, giving us O(n * h). In the worst case of a skewed tree, h = n, so O(n²)

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth is O(h) for tree height, plus O(w) for storing the widest level where w ≤ n

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
Node values are in the range [-1000, 1000]
Follow-up: Can you solve this iteratively and recursively?

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses BFS with deque prepending to achieve O(n) time complexity. Instead of doing standard level-order traversal and then reversing, we use a deque and prepend each level to the front as we process it. This naturally creates the bottom-up order without any additional reversal step, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n²)	O(h)	Find tree height, then traverse multiple times to collect each level separately
BFS with Deque (Optimal)	O(n)	O(w)	Use BFS with deque to prepend each level at the front, naturally creating bottom-up order
BFS with Result Reversal	O(n)	O(w)	Perform standard level-order traversal using BFS, then reverse the final result

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Calculate the height of the binary tree using recursive depth-first search
For each level from height-1 down to 0, perform a traversal to collect nodes at that level
Use a helper function that traverses the tree and collects nodes only at the target level
Combine all level results into the final bottom-up order

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Height

First, traverse the entire tree to find its height (3 levels in this case)

Collect Level 2 (Bottom)

Traverse tree again, collecting only nodes at depth 2: [15, 7]

Collect Level 1 (Middle)

Traverse tree again, collecting only nodes at depth 1: [9, 20]

Collect Level 0 (Top)

Traverse tree again, collecting only nodes at depth 0: [3]

Code -

solution.c — C

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

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

int getHeight(struct TreeNode* node) {
    if (!node) return 0;
    int leftHeight = getHeight(node->left);
    int rightHeight = getHeight(node->right);
    return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

void collectLevel(struct TreeNode* node, int targetLevel, int currentLevel, int* result, int* size) {
    if (!node) return;
    if (currentLevel == targetLevel) {
        result[(*size)++] = node->val;
        return;
    }
    
    collectLevel(node->left, targetLevel, currentLevel + 1, result, size);
    collectLevel(node->right, targetLevel, currentLevel + 1, result, size);
}

int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int height = getHeight(root);
    *returnSize = height;
    
    int** result = (int**)malloc(height * sizeof(int*));
    *returnColumnSizes = (int*)malloc(height * sizeof(int));
    
    for (int level = height - 1; level >= 0; level--) {
        int* levelNodes = (int*)malloc(10000 * sizeof(int));
        int size = 0;
        collectLevel(root, level, 0, levelNodes, &size);
        
        result[height - 1 - level] = levelNodes;
        (*returnColumnSizes)[height - 1 - level] = size;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse the tree h times (once for each level), and each traversal visits all n nodes, giving us O(n * h). In the worst case of a skewed tree, h = n, so O(n²)

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth is O(h) for tree height, plus O(w) for storing the widest level where w ≤ n

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
Node values are in the range [-1000, 1000]
Follow-up: Can you solve this iteratively and recursively?

98.0K Views

High Frequency

~15 min Avg. Time

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

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler