Binary Tree Zigzag Level Order Traversal - Practice Coding Problems

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

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.

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

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?

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
✓ 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)	O(n)	O(w)	Use BFS queue to traverse level by level, reversing alternate levels for zigzag pattern

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Find the maximum depth of the tree
For each level from 0 to max depth, traverse the entire tree
Collect nodes at the current level during each traversal
Reverse the node order for odd-numbered levels
Combine all levels into the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Depth

Traverse entire tree to find maximum depth

Level 0 Traversal

Traverse tree again to collect nodes at level 0

Level 1 Traversal

Traverse tree again for level 1, then reverse the result

Continue

Repeat for each level until max depth reached

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

int* getNodesAtLevel(struct TreeNode* node, int targetLevel, int currentLevel, int* returnSize) {
    *returnSize = 0;
    if (!node) return NULL;
    
    if (currentLevel == targetLevel) {
        int* result = (int*)malloc(sizeof(int));
        result[0] = node->val;
        *returnSize = 1;
        return result;
    }
    
    int leftSize, rightSize;
    int* leftNodes = getNodesAtLevel(node->left, targetLevel, currentLevel + 1, &leftSize);
    int* rightNodes = getNodesAtLevel(node->right, targetLevel, currentLevel + 1, &rightSize);
    
    if (leftSize == 0 && rightSize == 0) return NULL;
    
    int* result = (int*)malloc((leftSize + rightSize) * sizeof(int));
    for (int i = 0; i < leftSize; i++) {
        result[i] = leftNodes[i];
    }
    for (int i = 0; i < rightSize; i++) {
        result[leftSize + i] = rightNodes[i];
    }
    
    *returnSize = leftSize + rightSize;
    if (leftNodes) free(leftNodes);
    if (rightNodes) free(rightNodes);
    
    return result;
}

int** zigzagLevelOrder(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 levelSize;
        int* levelNodes = getNodesAtLevel(root, level, 0, &levelSize);
        
        if (level % 2 == 1) {
            // Reverse for odd levels
            for (int i = 0; i < levelSize / 2; i++) {
                int temp = levelNodes[i];
                levelNodes[i] = levelNodes[levelSize - 1 - i];
                levelNodes[levelSize - 1 - i] = temp;
            }
        }
        
        result[level] = levelNodes;
        (*returnColumnSizes)[level] = levelSize;
    }
    
    *returnSize = maxDepth;
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the h levels, we traverse all n nodes to find nodes at that specific level

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus space for storing one level at a time

✓ Linear Space

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?

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler