Stack Using Array - Problem

Implement a stack data structure using an array with the following operations:

push(x) - Add element x to the top of the stack
pop() - Remove and return the top element from the stack
peek() - Return the top element without removing it
isEmpty() - Check if the stack is empty
size() - Return the number of elements in the stack

The stack should handle multiple operations efficiently and maintain Last In, First Out (LIFO) order.

You will be given a list of operations to perform on the stack. Each operation is represented as a list where the first element is the operation name and the second element (if present) is the value to push.

Input & Output

Example 1 — Basic Stack Operations

$ Input: operations = [["push", 1], ["push", 2], ["peek"], ["pop"], ["isEmpty"]]

› Output: [2, 2, false]

💡 Note: Push 1, push 2 (stack: [1,2]), peek returns 2, pop returns 2 (stack: [1]), isEmpty returns false

Example 2 — Empty Stack Operations

$ Input: operations = [["push", 5], ["pop"], ["pop"], ["isEmpty"]]

› Output: [5, true]

💡 Note: Push 5, pop returns 5 (stack empty), second pop on empty stack, isEmpty returns true

Example 3 — Size Tracking

$ Input: operations = [["push", 10], ["push", 20], ["size"], ["pop"], ["size"]]

› Output: [2, 20, 1]

💡 Note: Push 10, push 20, size is 2, pop 20, size is 1

Constraints

1 ≤ operations.length ≤ 1000
-10⁴ ≤ values ≤ 10⁴
Pop and peek operations on empty stack return null
All operations should be handled efficiently

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is to use the end of an array as the stack top for O(1) operations. Best approach uses array with top pointer: Push/Pop at array end avoids shifting elements. Time: O(1) per operation, Space: O(n) for storage.

Common Approaches

✓ Array with Top Pointer

⏱️ Time: O(1) Space: O(n)

Keep track of the stack top using an index pointer. The stack grows towards the end of the array, and we always add/remove elements at the current top position.

Shift-Based Implementation

⏱️ Time: O(n) Space: O(n)

Treat the beginning of the array as the top of the stack. Every push operation shifts all existing elements to the right, and every pop operation shifts all remaining elements to the left.

Array with Top Pointer — Algorithm Steps

Initialize array and top pointer (-1 for empty)
For push: increment top, add element at top position
For pop: return element at top, decrement top
For peek: return element at top without changing top

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Operation

Add element to end, increment size

Pop Operation

Remove from end, decrement size

Result

All operations in O(1) time

Code -

solution.c — C

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

int main() {
    printf("[]
");  // Placeholder implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations work directly with the top pointer, no shifting required

✓ Linear Growth

Space Complexity

O(n)

Array storage for n stack elements plus constant extra space for pointer

⚡ Linearithmic Space

24.9K Views

High Frequency

~15 min Avg. Time

890 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

Stack Using Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array with Top Pointer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler