You understand the monotonic stack concept. You've memorized the template. But your "Next Greater Element" solution keeps failing test cases.
Sound familiar?
Next greater element problems have 5 common mistakes that trip up even experienced developers. These bugs are subtle, easy to make, and hard to debug without knowing what to look for.
This guide will show you the exact mistakes, why they happen, how to fix them, and how to avoid them in future problems.
The 5 common mistakes:
>= instead of >)Quick fix checklist:
> for next greater, < for next smallerresult = [-1] * n2 * n times❌ Wrong:
def nextGreaterElement(nums):
result = [-1] * len(nums)
stack = []
# WRONG: Iterating right to left
for i in range(len(nums) - 1, -1, -1):
while stack and nums[i] > nums[stack[-1]]:
result[stack.pop()] = nums[i]
stack.append(i)
return resultFor next greater to the RIGHT, we need to process left to right.
Visual:
Array: [2, 1, 2, 4, 3]
Processing right-to-left:
i=4 (val=3): stack=[4]
i=3 (val=4): 4 > 3, pop 4, result[4]=4 ✗ (wrong!)
The problem: We're finding next greater to the LEFT, not RIGHT!✅ Correct:
def nextGreaterElement(nums):
result = [-1] * len(nums)
stack = []
# CORRECT: Iterate left to right
for i in range(len(nums)):
while stack and nums[i] > nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i]
stack.append(i)
return resultLeft to right: Next greater to the right
for i in range(n): # →
# Find next greater for previous elementsRight to left: Next greater to the left (or previous greater)
for i in range(n - 1, -1, -1): # ←
# Find previous greater for future elements❌ Wrong:
# Using >= instead of >
while stack and nums[i] >= nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i]For "next GREATER", we need strictly greater (>), not greater or equal (>=).
Example:
Array: [2, 2, 3]
With >= (wrong):
i=0: stack=[0]
i=1: 2 >= 2, pop 0, result[0]=2 ✗ (2 is not greater than 2!)
With > (correct):
i=0: stack=[0]
i=1: 2 not > 2, stack=[0,1]
i=2: 3 > 2, pop 1, result[1]=3 ✓
3 > 2, pop 0, result[0]=3 ✓✅ Correct:
# Next GREATER: use >
while stack and nums[i] > nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i]
# Next SMALLER: use <
while stack and nums[i] < nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i]| Problem | Comparison | Reason |
|---|---|---|
| Next greater | > | Strictly greater |
| Next smaller | < | Strictly smaller |
| Next greater or equal | >= | Includes equal |
| Next smaller or equal | <= | Includes equal |
❌ Wrong:
def nextGreaterElement(nums):
result = [] # WRONG: Empty list
stack = []
for i in range(len(nums)):
while stack and nums[i] > nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i] # IndexError!
stack.append(i)
return resultError: IndexError: list assignment index out of range
We're trying to assign to result[idx] before the list has that index.
✅ Correct:
def nextGreaterElement(nums):
n = len(nums)
result = [-1] * n # CORRECT: Pre-initialize with default
stack = []
for i in range(n):
while stack and nums[i] > nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i] # Safe: index exists
stack.append(i)
return resultBenefits:
❌ Wrong:
def nextGreaterElements(nums):
"""
LeetCode #503: Next Greater Element II (Circular)
WRONG: Single pass
"""
n = len(nums)
result = [-1] * n
stack = []
# WRONG: Only one pass
for i in range(n):
while stack and nums[i] > nums[stack[-1]]:
result[stack.pop()] = nums[i]
stack.append(i)
return result
# Test
print(nextGreaterElements([1, 2, 1]))
# Output: [2, -1, 2] ✗ Wrong! Should be [2, -1, 2]
# Actually this example works, let me use a better oneBetter example:
print(nextGreaterElements([1, 2, 3, 4, 3]))
# Output: [2, 3, 4, -1, 4] ✗ Wrong!
# Expected: [2, 3, 4, -1, 4]
# Wait, let me think of a case that actually fails...
print(nextGreaterElements([5, 4, 3, 2, 1]))
# Output: [-1, -1, -1, -1, -1] ✗ Wrong!
# Expected: [-1, 5, 5, 5, 5] (wrapping around)Circular array means after the last element, we continue from the first. A single pass doesn't check wraparound.
Visual:
Array: [5, 4, 3, 2, 1]
Circular: [5, 4, 3, 2, 1, 5, 4, 3, 2, 1, ...]
Element 4: Next greater is 5 (wrapping around)
Element 3: Next greater is 5 (wrapping around)
...✅ Correct:
def nextGreaterElements(nums):
"""
LeetCode #503: Next Greater Element II (Circular)
CORRECT: Double pass with modulo
"""
n = len(nums)
result = [-1] * n
stack = []
# CORRECT: Iterate 2n times (double pass)
for i in range(2 * n):
idx = i % n # Wrap around using modulo
while stack and nums[idx] > nums[stack[-1]]:
result[stack.pop()] = nums[idx]
# Only push indices in first pass
if i < n:
stack.append(idx)
return result
# Test
print(nextGreaterElements([5, 4, 3, 2, 1]))
# Output: [-1, 5, 5, 5, 5] ✓ Correct!First pass (i=0 to n-1):
Second pass (i=n to 2n-1):
❌ Wrong (in some contexts):
def nextGreaterElement(nums):
result = [-1] * len(nums)
stack = []
for i in range(len(nums)):
while stack and nums[i] > nums[stack[-1]]:
result[stack.pop()] = nums[i]
stack.append(i)
# WRONG: Forgot to process remaining stack
# (Actually, this is fine for next greater to right!)
return resultThis mistake matters for:
For next greater element, it's fine because:
Example: Largest Rectangle in Histogram
def largestRectangleArea(heights):
heights = [0] + heights + [0] # Sentinels
stack = []
max_area = 0
for i in range(len(heights)):
while stack and heights[i] < heights[stack[-1]]:
h_idx = stack.pop()
width = i - stack[-1] - 1
area = heights[h_idx] * width
max_area = max(max_area, area)
stack.append(i)
# No need to process remaining stack
# (sentinels ensure all bars are processed)
return max_areaKey: Sentinels (0 at both ends) ensure all elements are processed during the loop.
When your next greater element solution fails:
> for next greater?
< for next smaller?
>= or <= unless needed?
n elements)?
2 * n iterations?
n iterations?
def nextGreaterElement(nums):
"""
Complete, correct template for next greater element.
Time: O(n)
Space: O(n)
"""
n = len(nums)
result = [-1] * n # ✓ Pre-initialized
stack = [] # Store indices
# ✓ Left to right for next greater to right
for i in range(n):
# ✓ Strict > for next GREATER
while stack and nums[i] > nums[stack[-1]]:
idx = stack.pop()
result[idx] = nums[i]
stack.append(i)
# ✓ Remaining elements already have -1
return result
def nextGreaterElementsCircular(nums):
"""
Circular array variant.
Time: O(n)
Space: O(n)
"""
n = len(nums)
result = [-1] * n
stack = []
# ✓ Double pass for circular
for i in range(2 * n):
idx = i % n # ✓ Modulo for wraparound
while stack and nums[idx] > nums[stack[-1]]:
result[stack.pop()] = nums[idx]
# ✓ Only push in first pass
if i < n:
stack.append(idx)
return resultTest your understanding:
Q: Why do we store indices instead of values?
A: For Daily Temperatures, we need to calculate distance (i - idx). Storing indices gives us that flexibility.
Q: Can I use >= for "next greater or equal"?
A: Yes, if the problem specifically asks for "greater or equal." But most problems want strictly greater.
Q: What if I need next greater to the left?
A: Iterate right-to-left, or use a different approach (immediate previous greater uses stack differently).
Q: How do I debug when my solution fails?
A: Trace through a small example by hand, printing stack state at each step. Compare with expected output.
Next greater element problems are straightforward once you avoid these 5 common mistakes.
The checklist:
> for greater, < for smallerresult = [-1] * n2 * n iterations with moduloThe template:
result = [-1] * n
stack = []
for i in range(n):
while stack and nums[i] > nums[stack[-1]]:
result[stack.pop()] = nums[i]
stack.append(i)
return resultMaster these fixes, and you'll never fail a next greater element problem again.
Next steps:
Next time your solution fails, check these 5 mistakes first.
LeetCopilot is a free browser extension that enhances your LeetCode practice with AI-powered hints, personalized study notes, and realistic mock interviews — all designed to accelerate your coding interview preparation.
Also compatible with Edge, Brave, and Opera
Add to Chrome for free