How do you approach Implement Queue using Stacks?

Use two stacks: one for pushing and one for popping.

What is the time complexity of Implement Queue using Stacks?

Time complexity: O(1) amortized for each operation. Space complexity: O(n) - for storing elements in the stacks.

What are common mistakes on Implement Queue using Stacks?

Popping without first checking the stack is non-empty. Ignoring what is left on the stack at the end - a non-empty stack is usually itself part of the answer. Pushing values where the problem needs indices back.

Sitelet https://gitgood.dev/coding/implement-queue-using-stacks

gitGood.dev

← Back to problems

Implement Queue using Stacks

EasyData Structures

Description

Implement a first-in-first-out (FIFO) queue using only two stacks. The queue should support the following operations: push, pop, peek, and empty.

You are given an array of commands, where each command is one of:

["push", x] - Push element x to the back of the queue. Returns null.
["pop"] - Remove the element from the front of the queue and return it.
["peek"] - Return the element at the front of the queue without removing it.
["empty"] - Return true if the queue is empty, false otherwise.

Return an array of results for each command.

Example 1

Input: commands = [["push", 1], ["push", 2], ["peek"], ["pop"], ["empty"]]

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

Explanation: push(1), push(2), peek() returns 1, pop() returns 1, empty() returns false

Constraints

- 1 <= commands.length <= 100 - 1 <= x <= 9 - All calls to pop and peek are valid (the queue is not empty when called).

Implement Queue using Stacks: approach, complexity and pitfalls

An easy stack problem, graded against 6 test cases (3 of them hidden).

The pattern: Stack

Last-in-first-out processing - matching, nesting, and deferred evaluation.

Reach for it when you see: Balanced brackets, nested structures, undo/back semantics, or expression evaluation.

If you are stuck

Show the 3-step hint ladder

Use two stacks: one for pushing and one for popping.
When you need to pop or peek and the output stack is empty, transfer all elements from the input stack.
Elements get reversed when moved between stacks, which gives us FIFO order.

The optimal approach

Show the approach: Two Stack Approach

Use two stacks: an input stack and an output stack. Push operations go to the input stack. For pop/peek, if the output stack is empty, transfer all elements from input to output (this reverses the order, giving FIFO behavior).

Time: O(1) amortized for each operation
Space: O(n) - for storing elements in the stacks

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.

Common Stack mistakes

These apply to the pattern as a whole, not just this problem.

Popping without first checking the stack is non-empty.
Ignoring what is left on the stack at the end - a non-empty stack is usually itself part of the answer.
Pushing values where the problem needs indices back.