Binary Tree Level Order Traversal

Binary Tree Level Order Traversal - Problem

Given the root of a binary tree, return the level order traversal of its nodes' values. This means visiting nodes level by level, from left to right within each level.

For example, if we have a binary tree with root value 3, left subtree with values 9, and right subtree with values 20, 15, 7 (where 15 and 7 are children of 20), we should return [[3], [9, 20], [15, 7]].

Each sub-array represents one level of the tree, ordered from top to bottom.

Input & Output

Example 1 — Complete Binary Tree

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

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

💡 Note: Level 0: [3], Level 1: [9,20], Level 2: [15,7]. We traverse left to right within each level.

Example 2 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Only one node at level 0, so result is [[1]].

Example 3 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree has no levels, return empty array.

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 65 A Amazon 58 M Microsoft 42 G Google 35

The key insight is using BFS with a queue to naturally process nodes level by level. Best approach is BFS Level-by-Level using queue size tracking to separate levels cleanly. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ Dfs

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

BFS Level-by-Level

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

Use a queue to process nodes level by level. Track the size of each level to separate them in the result.

DFS with Level Tracking

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

Traverse the tree using depth-first search, keeping track of each node's level. Store nodes in a result array where each index represents a level.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

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

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == INT_MIN) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode** queue = malloc(size * sizeof(struct TreeNode*));
    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] != INT_MIN) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != INT_MIN) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

void solution(int* rootArray, int size) {
    if (size == 0) {
        printf("[]\n");
        return;
    }
    
    struct TreeNode* root = buildTree(rootArray, size);
    if (!root) {
        printf("[]\n");
        return;
    }
    
    struct TreeNode** queue = malloc(size * 10 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    
    printf("[");
    int first_level = 1;
    
    while (front < rear) {
        int level_size = rear - front;
        
        if (!first_level) printf(",");
        first_level = 0;
        
        printf("[");
        
        for (int i = 0; i < level_size; i++) {
            struct TreeNode* node = queue[front++];
            
            if (i > 0) printf(",");
            printf("%d", node->val);
            
            if (node->left) {
                queue[rear++] = node->left;
            }
            if (node->right) {
                queue[rear++] = node->right;
            }
        }
        
        printf("]");
    }
    
    printf("]\n");
    free(queue);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL && size < 1000) {
        if (strcmp(token, "null") == 0) {
            arr[size++] = INT_MIN;
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    solution(arr, size);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

221.0K Views

High Frequency

~15 min Avg. Time

8.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