Codestin Search App

Binary Tree Zigzag Level Order Traversal - Problem

Binary Tree Zigzag Level Order Traversal

Imagine you're reading a book where each page is formatted in a unique zigzag pattern - the first line reads left to right, the second line reads right to left, and so on. Your task is to traverse a binary tree in a similar zigzag pattern!

Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. This means:
• Level 0: Read from left to right
• Level 1: Read from right to left
• Level 2: Read from left to right
• And so on, alternating directions...

The result should be a 2D array where each sub-array represents one level of the tree, with values arranged according to the zigzag pattern.

Input & Output

example_1.py — Standard Binary Tree

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

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

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

example_2.py — Single Node

$ Input: root = [1]

› Output: [[1]]

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

example_3.py — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree returns empty result array

Constraints

The number of nodes in the tree is in the range [0, 2000]
Node values are in range [-100, 100]
Tree can be unbalanced
Follow-up: Can you solve this using O(1) extra space?

Visualization

Tap to expand

Understanding the Visualization

Setup

Imagine each tree level as a line of text in a special book

Level 0

Read the first line normally from left to right: [3]

Level 1

Read the second line backwards from right to left: [9,20] → [20,9]

Level 2

Read the third line normally from left to right: [15,7]

Result

Combine all lines to get [[3], [20,9], [15,7]]

Key Takeaway

🎯 Key Insight: Use BFS to process levels sequentially, then simply reverse alternate levels to achieve the zigzag pattern efficiently in O(n) time.

Asked in

f Meta 85 ⊞ Microsoft 72 a Amazon 68 G Google 55 Apple 42 in LinkedIn 38

The optimal solution uses BFS (Breadth-First Search) with a queue to traverse the tree level by level in O(n) time. For each level, we collect all node values, then reverse alternate levels to achieve the zigzag pattern. This approach visits each node exactly once and uses O(w) space where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Level Tracking (Optimal)	O(n)	O(w)	Use BFS queue to traverse level by level, reversing alternate levels for zigzag pattern
Brute Force (Multiple Tree Traversals)	O(n²)	O(h)	Traverse the tree multiple times to get each level, then reverse alternate levels

BFS with Level Tracking (Optimal) — Algorithm Steps

Initialize a queue with the root node and level 0
While queue is not empty, process all nodes at current level
For each node, add its children to queue for next level
Collect current level's values in a list
If level is odd, reverse the list before adding to result
Move to next level and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root in queue at level 0

Process Level 0

Dequeue root, add children to queue, keep level 0 as-is

Process Level 1

Process nodes 9,20 and reverse since level 1 is odd

Process Level 2

Process nodes 15,7 in normal order since level 2 is even

Code -

solution.c — C

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

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

struct QueueNode {
    struct TreeNode* treeNode;
    int level;
};

struct Queue {
    struct QueueNode* items;
    int front;
    int rear;
    int capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->items = (struct QueueNode*)malloc(capacity * sizeof(struct QueueNode));
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* node, int level) {
    q->rear = (q->rear + 1) % q->capacity;
    q->items[q->rear].treeNode = node;
    q->items[q->rear].level = level;
}

struct QueueNode dequeue(struct Queue* q) {
    struct QueueNode item = q->items[q->front];
    q->front = (q->front + 1) % q->capacity;
    return item;
}

int queueSize(struct Queue* q) {
    return (q->rear - q->front + q->capacity + 1) % q->capacity;
}

int isEmpty(struct Queue* q) {
    return q->front == (q->rear + 1) % q->capacity;
}

void reverse(int* arr, int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!root) return NULL;
    
    struct Queue* q = createQueue(10000);
    enqueue(q, root, 0);
    
    int** result = (int**)malloc(2000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(2000 * sizeof(int));
    
    while (!isEmpty(q)) {
        int levelSize = queueSize(q);
        int* currentLevel = (int*)malloc(levelSize * sizeof(int));
        int levelNum = q->items[q->front].level;
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct QueueNode current = dequeue(q);
            currentLevel[i] = current.treeNode->val;
            
            // Add children for next level
            if (current.treeNode->left) {
                enqueue(q, current.treeNode->left, current.level + 1);
            }
            if (current.treeNode->right) {
                enqueue(q, current.treeNode->right, current.level + 1);
            }
        }
        
        // Reverse if odd level for zigzag pattern
        if (levelNum % 2 == 1) {
            reverse(currentLevel, levelSize);
        }
        
        result[*returnSize] = currentLevel;
        (*returnColumnSizes)[*returnSize] = levelSize;
        (*returnSize)++;
    }
    
    free(q->items);
    free(q);
    return result;
}

int main() {
    printf("BFS solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in BFS traversal, plus O(n/2) for reversing alternate levels

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree, typically O(n/2) for complete binary tree

✓ Linear Space

89.4K Views

High Frequency

~15 min Avg. Time

2.8K 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 Level Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler