Next Greater Element Using Stack in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Next Greater Element (NGE) for an element in an array?

The Next Greater Element for an element is the first element to its right in the array that is greater than it. If no such element exists, the NGE is -1.

intermediate

Why do we use a stack to solve the Next Greater Element problem efficiently?

A stack helps keep track of elements for which we haven't found the NGE yet. It allows us to process elements in a way that avoids repeated scanning, reducing time complexity from O(n²) to O(n).

intermediate

In the Next Greater Element algorithm using a stack, what do we do when the current element is greater than the element at the top of the stack?

We pop elements from the stack while the current element is greater than the top of the stack, assigning the current element as the NGE for those popped elements.

intermediate

What is the time complexity of the Next Greater Element algorithm using a stack?

The time complexity is O(n) because each element is pushed and popped at most once from the stack.

beginner

What value do we assign to elements that do not have a Next Greater Element?

We assign -1 to elements that do not have any greater element to their right.

What data structure is commonly used to solve the Next Greater Element problem efficiently?

A Queue

B Linked List

C Stack

D Array

Stack is used to keep track of elements waiting for their Next Greater Element.

If the current element is smaller than the top of the stack, what should you do in the Next Greater Element algorithm?

A Push the current element onto the stack

B Pop the stack

C Ignore the current element

D Replace the top of the stack

We push the current element onto the stack because it might be the NGE for future elements.

What is the Next Greater Element for the last element in the array?

A The first element

B -1

C The second last element

D The element itself

The last element has no elements to its right, so its NGE is -1.

What is the time complexity of the Next Greater Element algorithm using a stack?

A O(n)

B O(n log n)

C O(n²)

D O(log n)

Each element is pushed and popped at most once, so the algorithm runs in linear time.

What happens to elements remaining in the stack after processing the entire array?

A They become the Next Greater Element for others

B They are ignored

C They are removed without assignment

D They have no Next Greater Element, so assign -1

Remaining elements have no greater element to their right, so their NGE is -1.

Explain step-by-step how to find the Next Greater Element for each element in an array using a stack.

Think about how the stack helps track elements waiting for their NGE.

Why does using a stack reduce the time complexity of the Next Greater Element problem from O(n²) to O(n)?

Consider how many times each element is processed.

Practice

1. What does the Next Greater Element problem using a stack find for each element in an array?

easy

A. The sum of all elements greater than the current element

B. The first smaller element to the left of each element

C. The first greater element to the right of each element

D. The index of the maximum element in the array

Solution

1. Step 1: Understand the problem definition

   The Next Greater Element problem asks to find, for each element, the first element to its right that is greater than it.

2. Step 2: Identify the role of the stack

   The stack helps keep track of elements for which we haven't found a greater element yet, allowing efficient lookup.

3. Final Answer:

   The first greater element to the right of each element -> Option C

4. Quick Check:

   Next Greater Element = first greater right element [OK]

Hint: Look right for first bigger number using stack [OK]

Common Mistakes:

• Confusing next greater with next smaller element
• Searching to the left instead of right
• Thinking it finds max element overall

2. Which of the following Java code snippets correctly initializes a stack to solve Next Greater Element?

easy

A. Stack stack = new Stack<int>();

B. Stack<Integer> stack = new Stack<>();

C. Stack<int> stack = new Stack<>();

D. Stack<> stack = new Stack<Integer>();

Solution

1. Step 1: Check Java generic syntax for Stack

   Java uses generics with angle brackets and wrapper classes, so Stack<Integer> stack = new Stack<>(); is correct.

2. Step 2: Identify errors in other options

   Stack stack = new Stack<int>(); misses generic type parameter syntax; Stack<int> stack = new Stack<>(); uses primitive int which is invalid; Stack<> stack = new Stack<Integer>(); has incorrect generic syntax.

3. Final Answer:

   Stack<Integer> stack = new Stack<>(); -> Option B

4. Quick Check:

   Use wrapper class Integer with generics [OK]

Hint: Use Stack<Integer> stack = new Stack<>(); for integers [OK]

Common Mistakes:

• Using primitive int instead of Integer in generics
• Missing generic type parameter <>
• Incorrect generic syntax placement

3. What is the output of the following Java code for Next Greater Element?

int[] arr = {4, 5, 2, 25};
int[] nge = nextGreaterElement(arr);
System.out.println(Arrays.toString(nge));

public static int[] nextGreaterElement(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];
    Stack<Integer> stack = new Stack<>();
    for (int i = n - 1; i >= 0; i--) {
        while (!stack.isEmpty() && stack.peek() <= nums[i]) {
            stack.pop();
        }
        result[i] = stack.isEmpty() ? -1 : stack.peek();
        stack.push(nums[i]);
    }
    return result;
}

medium

A. [5, 25, 25, -1]

B. [25, -1, 5, -1]

C. [5, 25, -1, -1]

D. [-1, 25, 25, -1]

Solution

1. Step 1: Trace from right to left

   Start with i=3 (25): stack empty, result[3] = -1, push 25.
   i=2 (2): stack top=25 > 2, result[2]=25, push 2.
   i=1 (5): pop 2 (<=5), stack top=25 > 5, result[1]=25, push 5.
   i=0 (4): stack top=5 > 4, result[0]=5, push 4.

2. Step 2: Collect results

   Result array is [5, 25, 25, -1].

3. Final Answer:

   [5, 25, 25, -1] -> Option A

4. Quick Check:

   Right side bigger elements found correctly [OK]

Hint: Traverse array backward, use stack to track next greater [OK]

Common Mistakes:

• Traversing left to right instead of right to left
• Not popping smaller or equal elements from stack
• Assigning wrong default -1 positions

4. Identify the bug in this Next Greater Element code snippet:

public static int[] nextGreaterElement(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];
    Stack<Integer> stack = new Stack<>();
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && stack.peek() <= nums[i]) {
            stack.pop();
        }
        result[i] = stack.isEmpty() ? -1 : stack.peek();
        stack.push(nums[i]);
    }
    return result;
}

medium

A. Loop should run from right to left (i = n-1 to 0)

B. Stack should store indices, not values

C. Result array size is incorrect

D. Missing initialization of stack

Solution

1. Step 1: Analyze loop direction

   The code loops from left to right, but Next Greater Element using stack requires right to left traversal to find next greater on the right.

2. Step 2: Understand impact of loop direction

   Looping left to right causes incorrect results because stack does not have future elements yet.

3. Final Answer:

   Loop should run from right to left (i = n-1 to 0) -> Option A

4. Quick Check:

   Traverse backward for correct next greater [OK]

Hint: Traverse array backward to find next greater correctly [OK]

Common Mistakes:

• Looping forward instead of backward
• Using stack for values instead of indices (not always wrong but different approach)
• Not popping smaller or equal elements

5. Given the array {13, 7, 6, 12}, what is the Next Greater Element array using a stack? Also, explain why the last element's next greater element is -1.

hard

A. [ 7, 12, 13, -1 ]

B. [ -1, 13, 12, -1 ]

C. [ -1, 12, -1, -1 ]

D. [ -1, 12, 12, -1 ]

Solution

1. Step 1: Find next greater elements from right to left

   Start with 12 (last element): no elements to right, so result is -1.
   Next 6: next greater is 12.
   Next 7: next greater is 12.
   Next 13: no greater element to right, so -1.

2. Step 2: Explain last element's result

   The last element has no elements to its right, so no next greater element exists, hence -1.

3. Final Answer:

   [ -1, 12, 12, -1 ] -> Option D

4. Quick Check:

   Last element no right neighbor = -1 [OK]

Hint: Last element always -1, no elements to right [OK]

Common Mistakes:

• Assigning next greater for last element incorrectly
• Mixing up indices and values
• Not traversing array backward