Implement Stack using Queues - Practice Coding Problems

Implement Stack using Queues - Problem

Imagine you're a data structure architect tasked with creating a stack (Last-In-First-Out) using only queues (First-In-First-Out) as your building blocks!

A stack supports these operations:

push(x) - Add element to the top
pop() - Remove and return the top element
top() - View the top element without removing it
empty() - Check if the stack is empty

The challenge? You can only use standard queue operations:

Add to back of queue
Remove from front of queue
Check size and emptiness

This is like trying to make a plate dispenser (stack) work using only a cafeteria line system (queue)!

Input & Output

example_1.py — Basic Operations

$ Input: ["MyStack", "push", "push", "top", "pop", "empty"] [[], [1], [2], [], [], []]

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

💡 Note: Create stack, push 1 and 2, check top (should be 2 since it was last pushed), pop (returns and removes 2), check if empty (false since 1 is still there)

example_2.py — Single Element

$ Input: ["MyStack", "push", "pop", "empty"] [[], [1], [], []]

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

💡 Note: Create stack, push 1, pop it (returns 1), check if empty (true since no elements remain)

example_3.py — Multiple Operations

$ Input: ["MyStack", "push", "push", "push", "top", "pop", "top", "pop", "top"] [[], [1], [2], [3], [], [], [], [], []]

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

💡 Note: Shows LIFO behavior: push 1,2,3 then operations return elements in reverse order (3,2,1)

Constraints

1 ≤ x ≤ 10⁹
At most 100 calls will be made to push, pop, top, and empty
All calls to pop and top are guaranteed to be valid (stack won't be empty)

Visualization

Tap to expand

Understanding the Visualization

Normal Queue Behavior

In a regular queue, first person in line gets served first (FIFO)

Stack Requirement

We need the last person to join to be served first (LIFO)

The Rotation Solution

When serving, rotate everyone except the last person, serve them, then continue

Efficient for Adding

New people can join instantly, complexity only comes when serving

Key Takeaway

🎯 Key Insight: We can simulate any data structure using another, but the choice of which operations to optimize depends on the expected usage pattern. For write-heavy workloads, optimizing push over pop makes practical sense!

Asked in

a Amazon 42 ⊞ Microsoft 38 G Google 28 f Meta 22

The optimal approach uses a single queue with pop-heavy operations. Push operations are O(1) by simply adding to the back of the queue, while pop/top operations are O(n) by rotating elements. This is more efficient for write-heavy applications since most real-world scenarios involve more pushes than pops. The key insight is that we only need to maintain LIFO order when actually accessing the top element, not when adding new elements.

Common Approaches

Approach	Time	Space	Notes
✓ Single Queue with Pop-Heavy Approach (Optimal)	O(1) for push, O(n) for pop/top, O(1) for empty	O(1)	Make push O(1) and pop O(n) using only one queue
Two Queues with Push-Heavy Approach	O(n) for push, O(1) for pop/top/empty	O(n)	Make every push operation expensive by maintaining stack order

Single Queue with Pop-Heavy Approach (Optimal) — Algorithm Steps

For push: Simply add element to the back of the queue - O(1)
For pop: Rotate n-1 elements from front to back, then remove the front element
For top: Similar to pop but don't remove the element, then rotate it back
For empty: Check if queue is empty
This approach optimizes for the most common operation (push)

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Elements

Add 1, 2, 3 to queue - all O(1) operations

Pop Preparation

Rotate first 2 elements to back: [3, 1, 2]

Pop Element

Remove 3 from front - this was the last pushed (top of stack)

Result

Queue now has [1, 2] with 2 accessible for next pop

Code -

solution.c — C

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

#define MAX_SIZE 10000

typedef struct {
    int data[MAX_SIZE];
    int front, rear, size;
} MyStack;

MyStack* myStackCreate() {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    stack->front = 0;
    stack->rear = -1;
    stack->size = 0;
    return stack;
}

void myStackPush(MyStack* obj, int x) {
    // Simply add to the back - O(1)
    obj->rear = (obj->rear + 1) % MAX_SIZE;
    obj->data[obj->rear] = x;
    obj->size++;
}

int myStackPop(MyStack* obj) {
    // Rotate n-1 elements to bring last element to front
    int originalSize = obj->size;
    for (int i = 0; i < originalSize - 1; i++) {
        // Move front element to back
        int front = obj->data[obj->front];
        obj->front = (obj->front + 1) % MAX_SIZE;
        obj->size--;
        
        obj->rear = (obj->rear + 1) % MAX_SIZE;
        obj->data[obj->rear] = front;
        obj->size++;
    }
    // Now the 'top' element is at front, remove it
    int result = obj->data[obj->front];
    obj->front = (obj->front + 1) % MAX_SIZE;
    obj->size--;
    return result;
}

int myStackTop(MyStack* obj) {
    // Similar to pop but don't remove the element
    int originalSize = obj->size;
    for (int i = 0; i < originalSize - 1; i++) {
        int front = obj->data[obj->front];
        obj->front = (obj->front + 1) % MAX_SIZE;
        obj->size--;
        
        obj->rear = (obj->rear + 1) % MAX_SIZE;
        obj->data[obj->rear] = front;
        obj->size++;
    }
    // Peek at the front element
    int topElement = obj->data[obj->front];
    // Rotate it back to maintain order
    obj->front = (obj->front + 1) % MAX_SIZE;
    obj->size--;
    obj->rear = (obj->rear + 1) % MAX_SIZE;
    obj->data[obj->rear] = topElement;
    obj->size++;
    return topElement;
}

bool myStackEmpty(MyStack* obj) {
    return obj->size == 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) for push, O(n) for pop/top, O(1) for empty

Push just adds to back in constant time. Pop/top need to rotate n-1 elements to reach the 'top' element

✓ Linear Growth

Space Complexity

O(1)

Only uses one queue, no additional data structures needed

✓ Linear Space

68.0K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Single Queue with Pop-Heavy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler