Binary Tree Level Order Traversal - Practice Coding Problems

Binary Tree Level Order Traversal - Problem

You're given the root of a binary tree, and your task is to return the level order traversal of its nodes' values. This means you need to visit all nodes level by level, from left to right.

Think of it like reading a family tree or an organizational chart - you start at the top (root), then read all nodes at the second level from left to right, then all nodes at the third level from left to right, and so on.

Example: For a tree with root 3, left child 9, and right child 20 (where 20 has children 15 and 7), the level order traversal would be [[3], [9, 20], [15, 7]].

The result should be a 2D array where each inner array represents one level of the tree.

Input & Output

example_1.py — Python

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

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

💡 Note: Level 0 has node 3, Level 1 has nodes 9 and 20, Level 2 has nodes 15 and 7

example_2.py — Python

$ Input: root = [1]

› Output: [[1]]

💡 Note: Tree with only root node results in single level with one element

example_3.py — Python

$ Input: root = []

› Output: []

💡 Note: Empty tree returns empty result

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin with the root node in your queue - this is floor 0 with 1 person

Process Current Level

Take photos of all people on current floor, then send their children to the next floor down

Move to Next Level

Move to the next floor (next level) and repeat the process

Continue Until Empty

Keep going until there are no more floors to photograph

Key Takeaway

🎯 Key Insight: Use a queue to process one complete level at a time, ensuring perfect level-by-level traversal in optimal O(n) time

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes, where w is maximum width of tree

✓ Linear Space

Constraints

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

Asked in

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

The optimal solution uses Breadth-First Search (BFS) with a queue to process nodes level by level. By tracking the queue size at each iteration, we ensure that all nodes at the current level are processed before moving to the next level, naturally maintaining the left-to-right order within each level. This approach achieves O(n) time complexity with a single traversal and O(w) space complexity where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with Level Tracking)	O(n × h)	O(h)	Use depth-first search to find all nodes at each level separately
Two-Pass with Level Mapping	O(n + L)	O(n)	First pass to map nodes to levels, second pass to organize by levels
Breadth-First Search (BFS) - Optimal	O(n)	O(w)	Use queue to process nodes level by level in a single traversal

Brute Force (DFS with Level Tracking) — Algorithm Steps

Find the maximum depth of the tree
For each level from 0 to max depth:
Traverse the tree with DFS to collect nodes at current level
Add collected nodes to result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Depth

Traverse tree to find maximum depth

Level 0 Search

DFS to collect all nodes at level 0

Level 1 Search

DFS to collect all nodes at level 1

Continue

Repeat for each level until max depth

Code -

solution.c — C

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

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

int getMaxDepth(struct TreeNode* node) {
    if (!node) return 0;
    int leftDepth = getMaxDepth(node->left);
    int rightDepth = getMaxDepth(node->right);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

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

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int maxDepth = getMaxDepth(root);
    int** result = (int**)malloc(maxDepth * sizeof(int*));
    *returnColumnSizes = (int*)malloc(maxDepth * sizeof(int));
    
    for (int level = 0; level < maxDepth; level++) {
        int* levelNodes = (int*)malloc(1000 * sizeof(int));
        int size = 0;
        getLevelNodes(root, level, 0, levelNodes, &size);
        
        if (size > 0) {
            result[*returnSize] = levelNodes;
            (*returnColumnSizes)[*returnSize] = size;
            (*returnSize)++;
        } else {
            free(levelNodes);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × h)

We traverse the tree h times (where h is height), and each traversal visits n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height

✓ Linear Space

Constraints

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

125.0K Views

Very High Frequency

~15 min Avg. Time

2.9K 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 (DFS with Level Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler