Binary Tree Zigzag Level Order Traversal in Python

Binary tree zigzag level order traversal visits nodes level by level, alternating direction each level. The first level goes left to right, second level right to left, third level left to right, and so on.

Algorithm Approach

The solution uses a queue-based level order traversal with a flag to alternate direction ?

• Start with root in queue and flag = True
• For each level, collect all nodes
• If flag is True, add children left to right
• If flag is False, add children right to left
• Toggle flag after each level

Implementation

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def zigzag_level_order(root):
    if not root:
        return []
    
    result = []
    queue = [root]
    left_to_right = True
    
    while queue:
        level_size = len(queue)
        level_values = []
        
        # Process all nodes at current level
        for _ in range(level_size):
            node = queue.pop(0)
            level_values.append(node.val)
            
            # Add children to queue
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        # Reverse if we're going right to left
        if not left_to_right:
            level_values.reverse()
        
        result.append(level_values)
        left_to_right = not left_to_right
    
    return result

# Create the example tree: [3,9,20,null,null,15,7]
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)

print(zigzag_level_order(root))

[[3], [20, 9], [15, 7]]

Using Deque for Better Performance

For larger trees, using collections.deque provides O(1) operations ?

from collections import deque

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def zigzag_level_order_optimized(root):
    if not root:
        return []
    
    result = []
    queue = deque([root])
    left_to_right = True
    
    while queue:
        level_size = len(queue)
        level_values = deque()
        
        for _ in range(level_size):
            node = queue.popleft()
            
            # Add to front or back based on direction
            if left_to_right:
                level_values.append(node.val)
            else:
                level_values.appendleft(node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        result.append(list(level_values))
        left_to_right = not left_to_right
    
    return result

# Test with the same tree
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)

print(zigzag_level_order_optimized(root))

[[3], [20, 9], [15, 7]]

Comparison

Conclusion

Zigzag level order traversal alternates direction each level using a queue and direction flag. The deque approach provides better performance by avoiding list reversals.