Binary Tree Zigzag Level Order Traversal - Practice Coding Problems

Binary Tree Zigzag Level Order Traversal - Problem

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

In zigzag level order traversal:

Level 0 (root): traverse from left to right
Level 1: traverse from right to left
Level 2: traverse from left to right
And so on, alternating direction for each level

The result should be a 2D array where each sub-array contains the values of nodes at that level in the specified order.

Input & Output

Example 1 — Standard Tree

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

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

💡 Note: Level 0: [3] (left→right), Level 1: [9,20] becomes [20,9] (right→left), Level 2: [15,7] (left→right)

Example 2 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Only root node exists, so result is [[1]]

Example 3 — Left-Heavy Tree

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

› Output: [[1],[3,2],[4,5]]

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

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input Tree

Binary tree with nodes at multiple levels

Level-by-Level

Process each level with alternating directions

Zigzag Result

2D array with zigzag pattern: L→R, R→L, L→R...

Key Takeaway

🎯 Key Insight: Use BFS with direction tracking to build zigzag pattern in a single pass

Asked in

a Amazon 45 M Microsoft 38 G Google 32 f Facebook 28

The key insight is to use BFS level-order traversal while tracking direction for each level. Best approach uses BFS with direction tracking - single pass with deque operations for efficient zigzag pattern. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Direction Tracking	O(n)	O(w)	Single-pass BFS that tracks level direction and adds nodes accordingly
Level Order + Reverse Alternate Levels	O(n)	O(w)	Perform normal level-order traversal, then reverse every other level

BFS with Direction Tracking — Algorithm Steps

Step 1: Initialize BFS queue and direction flag (starts left-to-right)
Step 2: For each level, process all nodes in queue
Step 3: Add node values based on current direction
Step 4: Toggle direction for next level

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0 (L→R)

Add node 3 normally to result

Level 1 (R→L)

Add nodes 20,9 by inserting at front

Level 2 (L→R)

Add nodes 15,7 normally again

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

int** solution(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int** result = (int**)malloc(1000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(1000 * sizeof(int));
    
    struct TreeNode** queue = (struct TreeNode**)malloc(10000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    int leftToRight = 1;
    
    while (front < rear) {
        int levelSize = rear - front;
        result[*returnSize] = (int*)malloc(levelSize * sizeof(int));
        (*returnColumnSizes)[*returnSize] = levelSize;
        
        int* tempLevel = (int*)malloc(levelSize * sizeof(int));
        int tempIndex = 0;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            tempLevel[tempIndex++] = node->val;
            
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
        
        // Copy to result based on direction
        if (leftToRight) {
            for (int i = 0; i < levelSize; i++) {
                result[*returnSize][i] = tempLevel[i];
            }
        } else {
            for (int i = 0; i < levelSize; i++) {
                result[*returnSize][i] = tempLevel[levelSize - 1 - i];
            }
        }
        
        free(tempLevel);
        (*returnSize)++;
        leftToRight = !leftToRight;
    }
    
    free(queue);
    return result;
}

int main() {
    // Simplified for basic functionality
    struct TreeNode* root = createNode(3);
    root->left = createNode(9);
    root->right = createNode(20);
    root->right->left = createNode(15);
    root->right->right = createNode(7);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(root, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores maximum width w of tree, deque for current level

✓ Linear Space

78.0K Views

High Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

BFS with Direction Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler