What is the Stack pattern?

The Stack pattern is a systematic approach to solving a class of coding interview problems. By recognizing the Stack structure, you can solve problems in optimal time complexity using proven techniques.

When should I use the Stack pattern?

Use the Stack pattern when the problem structure matches its recognition signals — typically when brute force would be O(n²) or worse, and the pattern reduces complexity to O(n).

What is the time complexity of Stack?

The Stack pattern typically runs in O(n) time and uses O(n) space. The exact complexity depends on the specific sub-variant being applied.

Is Stack important for coding interviews?

Yes — the Stack pattern is frequently tested at FAANG companies and competitive engineering interviews. Mastering this pattern gives you a reliable framework to solve many problem variations quickly.

How do I practice the Stack pattern?

Start by studying the pattern's mental model and recognition signals on DSAPatterns, then practice the curated LeetCode problems below in order from Easy to Hard. Aim for pattern recognition before memorizing solutions.

← back to patterns

pattern / EASY

Stack.

LIFO data structure for nested or sequential processing

complexity

time

O(n)

space

O(n)

practice questions

browse and solve all 0 pattern questions →

02' — visual

interactive

Sliding window — k = 3

Maximum sum subarray

Window

[0, 2]

Sum

Step

0 / 3

03'

mental
model.

Push items, pop when condition is met. For monotonic stack, maintain increasing or decreasing order.

Stack problems involve LIFO processing, often for matching brackets, monotonic stacks, or expression evaluation.

when to use ✓

01Valid parentheses
02Daily temperatures
03Largest rectangle in histogram
04Min stack

when not ✗

01When random access is needed

04'

recognition signals

Matching brackets

Next greater element

Valid parentheses

Expression evaluation

Monotonic stackMin/Max stackExpression evaluationNext greater element

05'

templates

python

1# Beginner: Fixed-size sliding window
2def max_sum_k(nums, k):
3   n = len(nums)
4   if n < k:
5      return 0
6   window_sum = sum(nums[:k])
7   max_sum = window_sum
8   for i in range(k, n):
9      window_sum += nums[i] - nums[i - k]
10      max_sum = max(max_sum, window_sum)
11   return max_sum

common mistakes

01Popping too many or too few
02Forgetting to push back

interview tips

01Master monotonic stack pattern
02Practice next greater/smaller element

06'

practice this pattern

0 curated problems from LeetCode

See all

No questions found for this pattern yet.

07'

faq

1# Beginner: Fixed-size sliding window

2def max_sum_k(nums, k):

3 n = len(nums)

4 if n < k:

5 return 0

6 window_sum = sum(nums[:k])

7 max_sum = window_sum

8 for i in range(k, n):

9 window_sum += nums[i] - nums[i - k]

10 max_sum = max(max_sum, window_sum)

11 return max_sum