Level Order Traversal - Problem

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

In level order traversal, we visit all nodes at depth 0 first, then all nodes at depth 1, then all nodes at depth 2, and so on.

Each level should be displayed on a separate line.

Example:

For the tree:

The level order traversal would be:

3
9 20
15 7

Input & Output

Example 1 — Basic Tree

$ 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 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Only one level with a single node

Example 3 — Left-Heavy Tree

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

› Output: 1 2 3 4 5

💡 Note: Level 0: [1], Level 1: [2,3], Level 2: [4,5]

Constraints

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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 35 f Facebook 28

The key insight is using a queue to process nodes level by level. The BFS approach naturally visits all nodes at depth d before visiting any nodes at depth d+1. Time: O(n), Space: O(w) where w is maximum width.

Common Approaches

✓ Breadth-First Search with Queue

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

This is the classic approach for level order traversal. We use a queue to store nodes and process them level by level, naturally achieving the desired order.

Recursive Depth-First with Level Tracking

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

This approach uses recursive DFS traversal while keeping track of the current depth. For each level, we maintain a list of nodes and build the result level by level.

Breadth-First Search with Queue — Algorithm Steps

Start with root in queue
Process all nodes in current level
Add children of current level to queue
Repeat until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root in queue

Process Level

Process all nodes in current level, add children to queue

Next Level

Repeat until queue is empty

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;
}

void solution(struct TreeNode* root) {
    if (!root) return;
    
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        int levelValues[1000];
        int levelCount = 0;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            levelValues[levelCount++] = node->val;
            
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
        
        for (int i = 0; i < levelCount; i++) {
            if (i > 0) printf(" ");
            printf("%d", levelValues[i]);
        }
        printf("\n");
    }
}

struct TreeNode* buildTree(char* input) {
    if (strncmp(input, "[]", 2) == 0) return NULL;
    
    input++; // Skip [
    char* token = strtok(input, ",]");
    if (!token || strcmp(token, "null") == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        token = strtok(NULL, ",]");
        if (token && strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        token = strtok(NULL, ",]");
        if (token && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    struct TreeNode* root = buildTree(input);
    solution(root);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(w)

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

⚡ Linearithmic Space

28.5K Views

High Frequency

~15 min Avg. Time

980 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

Level Order Traversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search with Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler