What Is This Problem About?
This is a classic stack problem from GeeksForGeeks — "Reverse a Stack" (Medium | 4 Points). You can find it on GFG by Reverse a Stack.
You are given a stack. Your job is simple — reverse it. The element that was at the bottom should now be at the top, and vice versa.
Example:
Wait — the input and output look the same? That is because GFG displays the result top to bottom after reversal. So after reversing, 1 comes to the top, and printing top to bottom gives [1, 2, 3, 4]. The stack is indeed reversed internally.
Approach 1 — Using Two Extra Stacks
Intuition: Pop everything from the original stack into Stack 1 — this reverses the order once. Then pop everything from Stack 1 into Stack 2 — this reverses it again, back to original order. Now push everything from Stack 2 back into the original stack. The result? The original stack is reversed.
Why does this work? Two reversals cancel each other out to give you... wait, that sounds wrong. Let us trace it:
Hmm, that brings it back to the same thing. This approach with two stacks actually does NOT work correctly — it ends up restoring the original order. This is why the approach was commented out in the original code. Good observation to catch in an interview.
Lesson: Two full reversals = no change. One reversal = what we want. Keep this in mind.
Approach 2 — Using an ArrayList (Clean & Simple) ✅
Intuition: Pop all elements from the stack into an ArrayList. At this point, the ArrayList holds elements in reverse order (because popping reverses). Then push them back from index 0 to end. This is the clean, working solution.
The stack is now reversed. 1 is on top.
Time Complexity: O(n) — one pass to pop, one pass to push.
Space Complexity: O(n) — for the ArrayList.
Why this works: When you pop all elements into a list, the top element (last inserted) goes to index 0. When you push back from index 0, that element goes in first and ends up at the bottom. The bottom element (first inserted) was popped last, sits at the end of the list, and gets pushed last — ending up on top. That is a perfect reversal.
Approach 3 — Using Recursion (No Extra Space) ✅
This is the most elegant approach and the one interviewers love to ask about.
Intuition: Use two recursive functions:
reverseStack— pops the top element, recursively reverses the rest, then inserts the popped element at the bottom.insertAtBottom— holds all elements out while inserting one element at the very bottom, then restores everything.
Time Complexity: O(n²) — for each of n elements, insertAtBottom takes O(n).
Space Complexity: O(n) — recursive call stack.
Which Approach Should You Use?
| Approach | Time | Space | Simplicity | Interview Value |
| Two Extra Stacks | ❌ Does not work | O(n) | Simple | Low |
| ArrayList | O(n) | O(n) | Very Easy | Medium |
| Recursion | O(n²) | O(n) | Moderate | High |
For a coding interview, always mention the recursive approach — it shows you understand stack mechanics deeply. For production code, the ArrayList approach is cleaner and faster.
Key Takeaway
Reversing a stack is fundamentally about understanding LIFO. Because a stack only allows access from the top, you need a systematic way to invert the order — whether that is using auxiliary storage like an ArrayList, or using the call stack itself via recursion. Both are valid. Both teach you something different about how stacks behave.
The next time you see a problem that involves reversing, reordering, or inserting at the bottom of a stack — your first instinct should be recursion with insertAtBottom. It is a pattern that appears again and again in DSA.
And if you want to understand Stack from Scratch?
If you are just getting started with stacks or want a complete reference — I have written a detailed in-depth guide on the Stack Data Structure in Java covering everything from what a stack is, how LIFO works, all three implementations (Array, ArrayList, LinkedList), every operation explained with code, time complexity, advantages, disadvantages, real-world use cases, and six practice problems with full solutions.
Check it out here → Stack Data Structure in Java: The Complete Guide
It is the perfect companion to this problem walkthrough — start there if you want the full picture, then come back here for the problem-solving side.
