Zigzag Iterator - Practice Coding Problems

Zigzag Iterator - Problem

Imagine you have two lists of numbers, and you want to create an iterator that returns elements from both lists in a zigzag pattern - first from list 1, then from list 2, then back to list 1, and so on.

Your task is to implement a ZigzagIterator class with the following methods:

ZigzagIterator(v1, v2): Initialize with two integer vectors
hasNext(): Returns true if there are more elements to iterate
next(): Returns the next element in zigzag order

Example: Given v1 = [1,2] and v2 = [3,4,5,6], the iterator should return elements in order: 1, 3, 2, 4, 5, 6

This is a classic design pattern problem that tests your understanding of iterators and state management!

Input & Output

example_1.py — Basic Zigzag

$ Input: v1 = [1,2], v2 = [3,4,5,6]

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

💡 Note: The iterator alternates between v1 and v2: first 1 from v1, then 3 from v2, then 2 from v1, then 4 from v2, and finally the remaining elements 5,6 from v2

example_2.py — Empty Vector

$ Input: v1 = [1], v2 = []

› Output: [1]

💡 Note: When one vector is empty, the iterator simply returns all elements from the non-empty vector

example_3.py — Equal Length

$ Input: v1 = [1,2,3], v2 = [4,5,6]

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

💡 Note: With equal length vectors, the pattern is perfectly alternating until both vectors are exhausted

Visualization

Tap to expand

Understanding the Visualization

Setup

Dealer has two decks: Blue deck [1,2] and Orange deck [3,4,5,6]

Deal Pattern

Deal from Blue → Orange → Blue → Orange, continuing until decks are empty

Queue Management

Use a queue to remember deck order, rotating decks as they're used

Completion

When a deck is empty, it's removed from rotation naturally

Key Takeaway

🎯 Key Insight: Use a queue to naturally rotate between vectors, eliminating the need for complex state tracking or pre-merging. The queue automatically handles the zigzag pattern and gracefully removes exhausted vectors.

Time & Space Complexity

Time Complexity

⏱️

O(1)

O(1) for each next() and hasNext() operation, total O(n+m) for all elements

✓ Linear Growth

Space Complexity

O(1)

Only storing pointers and queue with at most 2 elements, no extra space for merging

✓ Linear Space

Constraints

0 ≤ v1.length, v2.length ≤ 1000
1 ≤ v1[i], v2[i] ≤ 1000
At most 1000 calls will be made to next and hasNext
Follow up: What if you are given k vectors? How would you extend your solution?

Asked in

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

The optimal solution uses a queue-based approach with two pointers to maintain the zigzag pattern efficiently. Instead of pre-merging all elements, we use a queue to track which vector to read from next, along with the current position in each vector. This achieves O(1) space complexity (excluding input) and O(1) time per operation, making it both memory-efficient and performant.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Queue (Optimal)	O(1)	O(1)	Use queue to track vectors and maintain pointers for each vector
Pre-merge All Elements	O(n+m)	O(n+m)	Combine both vectors into one list during initialization

Two Pointers with Queue (Optimal) — Algorithm Steps

Initialize a queue with both vectors and their starting positions
For next(): dequeue a vector, return its current element, advance its pointer
If the vector still has elements, enqueue it back
For hasNext(): check if queue is non-empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Queue contains (v1,0) and (v2,0) representing vectors and their indices

First next()

Dequeue (v1,0), return v1[0]=1, enqueue (v1,1) back since v1 has more elements

Continue Pattern

Queue rotates between vectors, maintaining zigzag order naturally

Code -

solution.c — C

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

typedef struct {
    int* vec;
    int size;
    int index;
} VectorState;

typedef struct {
    VectorState queue[2];
    int queueSize;
} ZigzagIterator;

ZigzagIterator* zigzagIteratorCreate(int* v1, int v1Size, int* v2, int v2Size) {
    ZigzagIterator* it = (ZigzagIterator*)malloc(sizeof(ZigzagIterator));
    it->queueSize = 0;
    
    if (v1Size > 0) {
        it->queue[it->queueSize++] = (VectorState){v1, v1Size, 0};
    }
    if (v2Size > 0) {
        it->queue[it->queueSize++] = (VectorState){v2, v2Size, 0};
    }
    
    return it;
}

int zigzagIteratorNext(ZigzagIterator* obj) {
    VectorState curr = obj->queue[0];
    
    // Shift queue
    for (int i = 0; i < obj->queueSize - 1; i++) {
        obj->queue[i] = obj->queue[i + 1];
    }
    obj->queueSize--;
    
    int result = curr.vec[curr.index];
    curr.index++;
    
    if (curr.index < curr.size) {
        obj->queue[obj->queueSize++] = curr;
    }
    
    return result;
}

bool zigzagIteratorHasNext(ZigzagIterator* obj) {
    return obj->queueSize > 0;
}

int main() {
    int v1[] = {1, 2};
    int v2[] = {3, 4, 5, 6};
    ZigzagIterator* it = zigzagIteratorCreate(v1, 2, v2, 4);
    
    while (zigzagIteratorHasNext(it)) {
        printf("%d ", zigzagIteratorNext(it));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

O(1) for each next() and hasNext() operation, total O(n+m) for all elements

✓ Linear Growth

Space Complexity

O(1)

Only storing pointers and queue with at most 2 elements, no extra space for merging

✓ Linear Space

Constraints

0 ≤ v1.length, v2.length ≤ 1000
1 ≤ v1[i], v2[i] ≤ 1000
At most 1000 calls will be made to next and hasNext
Follow up: What if you are given k vectors? How would you extend your solution?

62.0K Views

Medium Frequency

~18 min Avg. Time

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers with Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler