Implement Queue using Stacks - Practice Coding Problems

Implement Queue using Stacks - Problem

Implement a Queue using Two Stacks

Your mission is to create a First In, First Out (FIFO) queue data structure using only two stacks. Think of a queue like a line at a coffee shop - the first person in line gets served first!

You need to implement the MyQueue class with these operations:

push(x) - Add element x to the back of the queue
pop() - Remove and return the element from the front
peek() - Return the front element without removing it
empty() - Check if the queue is empty

The Challenge: You can only use standard stack operations: push, pop, top, and empty. No direct access to queue operations allowed!

Example:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek(); // returns 1
queue.pop();  // returns 1
queue.empty(); // returns false

Input & Output

example_1.py — Basic Operations

$ Input: ["MyQueue", "push", "push", "peek", "pop", "empty"] [[], [1], [2], [], [], []]

› Output: [null, null, null, 1, 1, false]

💡 Note: Create queue, push 1 and 2. peek() returns 1 (front element). pop() removes and returns 1. empty() returns false since 2 is still in queue.

example_2.py — Single Element

$ Input: ["MyQueue", "push", "pop", "empty"] [[], [42], [], []]

› Output: [null, null, 42, true]

💡 Note: Push single element 42, pop it (returns 42), then queue becomes empty.

example_3.py — Multiple Operations

$ Input: ["MyQueue", "push", "push", "push", "pop", "push", "peek", "pop", "pop"] [[], [1], [2], [3], [], [4], [], [], []]

› Output: [null, null, null, null, 1, null, 2, 2, 3]

💡 Note: Push 1,2,3 then pop 1. Push 4. Queue now has [2,3,4]. peek() returns 2, pop() returns 2 and 3.

Visualization

Tap to expand

Understanding the Visualization

Push Phase

All new elements go into the input stack, just like stacking plates

Transfer Trigger

When we need to pop/peek and output stack is empty, transfer all elements

Order Reversal

The transfer process reverses the order, making FIFO access possible

Efficient Access

Now we can pop/peek from output stack in proper queue order

Key Takeaway

🎯 Key Insight: Using two stacks cleverly transforms LIFO operations into FIFO behavior through strategic element transfers, achieving optimal amortized performance!

Time & Space Complexity

Time Complexity

⏱️

O(1) amortized

Each element is transferred at most twice across its lifetime. Push is always O(1), pop/peek are amortized O(1)

✓ Linear Growth

Space Complexity

O(n)

Space needed for two stacks to hold all n elements

⚡ Linearithmic Space

Constraints

1 ≤ x ≤ 10⁹
At most 100 calls will be made to push, pop, peek, and empty
All calls to pop and peek are valid (queue is not empty)

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28 Apple 22

The optimal solution uses two stacks strategically: one for input operations and one for output operations. The key insight is that transferring elements between stacks reverses their order, converting LIFO behavior into FIFO behavior. This achieves amortized O(1) time complexity for all operations since each element is moved at most twice during its lifetime.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Single Stack with Array)	O(n)	O(n)	Use one stack and an auxiliary array to maintain queue order
Two Stacks - Optimal Solution	O(1) amortized	O(n)	Use two stacks: one for input, one for output with amortized O(1) operations

Brute Force (Single Stack with Array) — Algorithm Steps

For push: simply add element to the stack
For pop/peek: transfer all elements to auxiliary array
Access the first element from the array (front of queue)
Transfer all remaining elements back to stack
Return the accessed element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Stack contains [1,2,3] and we want to pop the front element (1)

Transfer to Auxiliary

Move all elements to auxiliary array: [3,2,1]

Access Front

Get element 1 from the end of auxiliary array

Transfer Back

Move remaining elements [3,2] back to stack

Code -

solution.c — C

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

typedef struct {
    int* stack;
    int top;
    int capacity;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    queue->capacity = 1000;
    queue->stack = (int*)malloc(queue->capacity * sizeof(int));
    queue->top = -1;
    return queue;
}

void myQueuePush(MyQueue* obj, int x) {
    obj->stack[++obj->top] = x;
}

int myQueuePop(MyQueue* obj) {
    // Transfer all elements to auxiliary array
    int aux[1000];
    int auxTop = -1;
    
    while (obj->top >= 0) {
        aux[++auxTop] = obj->stack[obj->top--];
    }
    
    // Get the front element
    int result = aux[auxTop--];
    
    // Put remaining elements back
    while (auxTop >= 0) {
        obj->stack[++obj->top] = aux[auxTop--];
    }
    
    return result;
}

int myQueuePeek(MyQueue* obj) {
    // Transfer all elements to auxiliary array
    int aux[1000];
    int auxTop = -1;
    
    while (obj->top >= 0) {
        aux[++auxTop] = obj->stack[obj->top--];
    }
    
    // Get the front element
    int result = aux[auxTop];
    
    // Put all elements back
    while (auxTop >= 0) {
        obj->stack[++obj->top] = aux[auxTop--];
    }
    
    return result;
}

bool myQueueEmpty(MyQueue* obj) {
    return obj->top == -1;
}

void myQueueFree(MyQueue* obj) {
    free(obj->stack);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Every pop() and peek() operation requires transferring all n elements twice

✓ Linear Growth

Space Complexity

O(n)

Additional space needed for the auxiliary array to hold all elements

⚡ Linearithmic Space

Constraints

1 ≤ x ≤ 10⁹
At most 100 calls will be made to push, pop, peek, and empty
All calls to pop and peek are valid (queue is not empty)

67.0K Views

High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Single Stack with Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler