Stack interview questions are commonly asked to assess your understanding of the LIFO principle, stack operations, and problem-solving techniques. This collection covers the most important questions to help you prepare for coding and technical interviews.
- Covers the most frequently asked Stack interview questions with concise answers.
- Suitable for both freshers and experienced professionals preparing for technical interviews.
Table of Content
Theoretical Questions for Interviews
1. What is a Stack?
A Stack is a linear data structure that follows the Last In, First Out (LIFO) principle. The last element inserted into the stack is the first one to be removed. It is widely used in function calls, expression evaluation, and backtracking algorithms.
- Follows the LIFO (Last In, First Out) principle.
- Insertion and deletion occur only at the top of the stack.
- Can be implemented using an array or a linked list.
2. What are the operations performed on a Stack?
A Stack supports a few basic operations that allow insertion, deletion, and retrieval of elements from the top. These operations are efficient and commonly used in many applications.
- Push: Inserts an element onto the top of the stack.
- Pop: Removes the top element from the stack.
- Peek (Top): Returns the top element without removing it.
- isEmpty(): Checks whether the stack is empty.
3. How is a Stack implemented using a Linked List?
A Stack can also be implemented using a linked list, where the head node represents the top of the stack. This implementation allows the stack to grow dynamically without requiring a fixed size.
- Push inserts a node at the head.
- Pop removes the head node.
- No fixed-size limitation.
- Push and Pop take O(1) time.
4. How is a Stack implemented using an Array?
A Stack can be implemented using an array by maintaining an index called top, which always points to the current top element. The push operation increments the top index, while pop decrements it.
- Store elements in an array.
- Maintain a top variable.
- Push and Pop operations take O(1) time.
5. What is the time complexity of Stack operations?
The basic Stack operations are performed only at the top, making them highly efficient. Their time complexity remains constant in both array and linked list implementations.
| Operation | Time Complexity |
|---|---|
| Push | O(1) |
| Pop | O(1) |
| Peek | O(1) |
| isEmpty | O(1) |
| Search | O(n) |
6. What are the applications of a Stack?
Stacks are widely used in computer science because they efficiently manage data in LIFO order. They are commonly used in programming languages, compilers, and algorithms.
- Function call management and recursion.
- Expression evaluation and conversion.
- Undo/Redo operations in editors.
- Backtracking and Depth First Search (DFS).
For more detail -> Applications of a Stack
7. What is Stack Overflow?
A Stack Overflow occurs when an attempt is made to push an element onto a full stack. In recursive programs, it can also occur when excessive function calls exhaust the available stack memory.
- Occurs when the stack exceeds its capacity.
- Common in fixed-size array implementations.
- Can happen due to infinite recursion.
8. What is Stack Underflow?
A Stack Underflow occurs when an attempt is made to remove or access an element from an empty stack. It indicates that there are no elements available for the requested operation.
- Happens when the stack is empty.
- Occurs during pop or peek operations.
- Should be handled using an isEmpty() check.
9. What is the difference between Stack and Queue?
A Stack and a Queue are both linear data structures, but they differ in the order in which elements are processed.
| Stack | Queue |
|---|---|
| Follows LIFO | Follows FIFO |
| Insert/Delete at top | Insert at rear, delete from front |
| Uses Push and Pop | Uses Enqueue and Dequeue |
| Used in recursion | Used in scheduling |
10. Why is Stack useful for function call management?
Programming languages use a stack to manage function calls because it naturally follows the order in which functions are invoked and returned.
- Stores function parameters and local variables.
- Keeps the return address.
- Supports recursive function calls efficiently.
11. How do you implement a Stack using two Queues?
A Stack can be implemented using two queues by rearranging elements during the push or pop operation so that the last inserted element is always removed first.
- Use two queues.
- Transfer elements between queues to maintain LIFO order.
- Push or Pop can be made efficient depending on the implementation.
12. What is a Postfix Expression, and how is it evaluated using a Stack?
A Postfix expression is one in which the operator appears after its operands. A stack is used to evaluate the expression efficiently.
- Traverse the expression from left to right.
- Push operands onto the stack.
- On encountering an operator, pop operands, evaluate, and push the result.
13. What is a Prefix Expression, and how is it evaluated using a Stack?
A Prefix expression places the operator before its operands. It is evaluated using a stack by scanning the expression from right to left.
- Traverse from right to left.
- Push operands onto the stack.
- On encountering an operator, pop operands, evaluate, and push the result.
14. What is the time complexity of converting Infix to Postfix?
An infix expression can be converted into postfix using a stack to temporarily store operators while respecting operator precedence and associativity.
- Each character is processed only once.
- Stack operations take constant time.
- Time Complexity: O(n).
15. What is the time complexity of converting Infix to Prefix?
Convert an infix expression to postfix involves reversing the expression, converting it to postfix, and then reversing the result.
- Reverse the infix expression.
- Convert to postfix using a stack.
- Reverse the postfix expression.
- Time Complexity: O(n).
16. How do you check balanced parentheses using a Stack?
A stack is commonly used to determine whether an expression containing brackets is balanced by matching every opening bracket with its corresponding closing bracket.
- Push every opening bracket onto the stack.
- Pop when a matching closing bracket is encountered.
- If the stack is empty at the end, the expression is balanced.
- Supports (), {}, and [].
For more Detail-> Check balanced parentheses using a Stack
17. What is the time complexity of inserting an element at the bottom of a Stack?
To Insert an Bottom at the bottom, all existing elements must first be removed and then added back after inserting the new element.
- Pop all elements recursively.
- Insert the new element at the bottom.
- Push all removed elements back.
- Time Complexity: O(n), where n is the number of elements in the stack.
18. What is the difference between a Static Stack and a Dynamic Stack?
A Stack can be implemented using either a fixed-size array (static stack) or a dynamically allocated linked list (dynamic stack). The choice depends on memory requirements and application needs.
- Static Stack: Implemented using an array with a fixed size.
- Dynamic Stack: Implemented using a linked list and can grow or shrink dynamically.
19. How do you reverse a Stack?
A Stack can be reversed by using recursion or an auxiliary stack. In the recursive approach, elements are removed one by one and inserted back at the bottom of the stack.
- Pop all elements recursively.
- Insert each element at the bottom while returning from recursion.
- Can also be reversed using an additional stack.
- Time Complexity: O(n).
20. Why is the LIFO principle important in a Stack?
The Last In, First Out (LIFO) principle ensures that the most recently inserted element is accessed first. This behavior is useful in scenarios where recent operations need to be processed before earlier ones.
- Supports function calls and recursion.
- Used in Undo/Redo operations.
- Helps in expression evaluation and syntax parsing.
- Simplifies backtracking algorithms such as Depth First Search (DFS).
Coding Interview Questions
The following list of 50 stack coding problems covers a range of difficulty levels, from easy to hard, to help candidates prepare for interviews.
Easy Problems
- Parenthesis Checker
- Reverse a String using Stack
- Postfix to Prefix
- Two stacks in an array
- Delete Middle element from stack
- Reverse individual words
Medium Problems
- Queue using Stacks
- Stack using Queues
- Stack using single queue
- Evaluate Postfix Expression
- Next Greater Element
- Nearest Smaller Element
- Next Smaller of next Greater
- Sort a stack using a temporary stack
- Stock Span Problem
- Reverse a Stack using recursion
- Infix to Postfix
- Delete consecutive same words
- A Stack with getMin() in O(1) Time
- Count of Subarrays with first as minimum
- Length of the longest valid substring
- Index of closing bracket
- Next Greater Frequency Element
- Max Diff between nearest smallers
- Max product of indexes of next greater
- The Celebrity Problem
Hard Problems
- Valid stack permutation
- Stack with getMin() in O(1)
- Stack with getRandom() in O(1)
- Equivalent expressions
- k stacks in a single array
- Largest rectangular area in a histogram
- Clone a Stack without Extra Space
- Custom Browser History
- Maximum Rectangle with all 1s
- Sort a stack using Recursion
- Stack with findMiddle() and deleteMiddle()
- Maximum visible people
- Count distinct Max Differences in Subarrays
- Longest Correct Bracket Subsequence Set
- Maximum of minimum for every window size