Codestin Search App

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.

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)

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!

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
✓ 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)	O(n)	O(n)	Use one stack and an auxiliary array to maintain queue order

Two Stacks - Optimal Solution — Algorithm Steps

Maintain two stacks: input_stack and output_stack
For push(): always add to input_stack
For pop()/peek(): if output_stack is empty, transfer all from input_stack to output_stack
Then pop/peek from output_stack (which now has elements in FIFO order)
For empty(): check if both stacks are empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Operations

Elements 1,2,3 are pushed to input stack

First Pop Request

Output stack is empty, so transfer all from input to output

Order Reversal

Transfer reverses order: [3,2,1] becomes [1,2,3] in output stack

Pop from Output

Now we can pop from output stack in FIFO order

Code -

solution.c — C

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

typedef struct {
    int* inputStack;
    int* outputStack;
    int inputTop;
    int outputTop;
    int capacity;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    queue->capacity = 1000;
    queue->inputStack = (int*)malloc(queue->capacity * sizeof(int));
    queue->outputStack = (int*)malloc(queue->capacity * sizeof(int));
    queue->inputTop = -1;
    queue->outputTop = -1;
    return queue;
}

void transferIfNeeded(MyQueue* obj) {
    // Only transfer when output stack is empty
    if (obj->outputTop == -1) {
        while (obj->inputTop >= 0) {
            obj->outputStack[++obj->outputTop] = obj->inputStack[obj->inputTop--];
        }
    }
}

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

int myQueuePop(MyQueue* obj) {
    transferIfNeeded(obj);
    return obj->outputStack[obj->outputTop--];
}

int myQueuePeek(MyQueue* obj) {
    transferIfNeeded(obj);
    return obj->outputStack[obj->outputTop];
}

bool myQueueEmpty(MyQueue* obj) {
    return obj->inputTop == -1 && obj->outputTop == -1;
}

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

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

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

Constraints

Visualization

Related Problems

Common Approaches

Two Stacks - Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler