Validate Stack Sequences - Practice Coding Problems

Validate Stack Sequences - Problem

Imagine you're watching someone use a stack data structure, but you can only see the push and pop sequences they performed. Given two integer arrays pushed and popped, each containing distinct values, your task is to determine if these sequences could represent valid stack operations on an initially empty stack.

The pushed array shows the order in which elements were pushed onto the stack, while popped shows the order in which elements were popped from the stack. Remember that a stack follows LIFO (Last In, First Out) principle - you can only pop the most recently pushed element that hasn't been popped yet.

Goal: Return true if the given sequences are valid, false otherwise.

Example: If pushed = [1,2,3,4,5] and popped = [4,5,3,2,1], this is valid because we could: push 1,2,3,4 → pop 4 → push 5 → pop 5 → pop 3 → pop 2 → pop 1

Input & Output

example_1.py — Valid Stack Sequence

$ Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]

› Output: true

💡 Note: We can achieve this sequence: push 1,2,3,4 → pop 4 → push 5 → pop 5 → pop 3 → pop 2 → pop 1. The stack operations follow LIFO order correctly.

example_2.py — Invalid Stack Sequence

$ Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]

› Output: false

💡 Note: After popping 4 and 3, element 5 hasn't been pushed yet when we try to pop it. The sequence violates stack LIFO constraints.

example_3.py — Single Element

$ Input: pushed = [1], popped = [1]

› Output: true

💡 Note: Simple case: push 1, then pop 1. This is obviously valid.

Constraints

1 ≤ pushed.length ≤ 1000
0 ≤ pushed[i] ≤ 1000
All elements in pushed are unique
popped.length == pushed.length
popped is a permutation of pushed

Visualization

Tap to expand

Understanding the Visualization

Stack Clean Plates

Kitchen staff stack plates 1,2,3,4 in order

Serve Customer

Customer needs plate 4 (top plate) - serve immediately

Add More Plates

Stack plate 5, then serve it when requested

Continue Service

Serve remaining plates 3,2,1 from top of stack

Validation Complete

All plates served in correct LIFO order - sequence valid!

Key Takeaway

🎯 Key Insight: The greedy simulation approach works because stack operations are deterministic - when the top element matches our target, we must pop it immediately rather than waiting.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal approach uses stack simulation with a greedy strategy. We simulate the stack operations by pushing elements and immediately popping when the stack top matches the next target in the popped sequence. This works because if we can pop an element, we must do it immediately - delaying would only make future operations impossible. The algorithm runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Stack Simulation (Optimal)	O(n)	O(n)	Simulate the stack operations greedily - push when needed, pop when possible

Stack Simulation (Optimal) — Algorithm Steps

Initialize an empty stack and pointer for popped array
For each element in pushed array, push it onto stack
While stack top matches current target pop element, pop it
Increment pop pointer after each successful pop
Return true if all elements were successfully popped

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Elements

Push elements from pushed array one by one

Check Top

After each push, check if stack top matches next pop target

Pop Greedily

Pop immediately when stack top matches pop target

Validate Result

If all elements popped successfully, sequence is valid

Code -

solution.c — C

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

bool validateStackSequences(int* pushed, int pushedSize, int* popped, int poppedSize) {
    int* stack = (int*)malloc(pushedSize * sizeof(int));
    int stackSize = 0;
    int popIdx = 0;
    
    for (int i = 0; i < pushedSize; i++) {
        stack[stackSize++] = pushed[i];
        
        // Pop while possible and matches target
        while (stackSize > 0 && popIdx < poppedSize && 
               stack[stackSize - 1] == popped[popIdx]) {
            stackSize--;
            popIdx++;
        }
    }
    
    free(stack);
    return popIdx == poppedSize;
}

int main() {
    // Example usage
    int pushed[] = {1, 2, 3, 4, 5};
    int popped[] = {4, 5, 3, 2, 1};
    
    printf("%s\n", validateStackSequences(pushed, 5, popped, 5) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped at most once, so linear time

✓ Linear Growth

Space Complexity

O(n)

Simulation stack can hold up to n elements in worst case

⚡ Linearithmic Space

126.8K 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

Stack Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler