Next Greater Element Using Stack in DSA C - 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 the right of it 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 NGE 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 until the top element is greater than the current element or the stack is empty. For each popped element, the current element is its Next Greater Element.

beginner

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 will be the output for the array [4, 5, 2, 25] using the Next Greater Element algorithm?

The output will be [5, 25, 25, -1]. Explanation: 4's NGE is 5, 5's NGE is 25, 2's NGE is 25, and 25 has no greater element to its right.

What does the stack store in the Next Greater Element algorithm?

A Indices or values of elements waiting for their NGE

B Only the largest element in the array

C All elements in sorted order

D Elements that already have their NGE found

The stack stores elements (or their indices) for which we haven't found the Next Greater Element yet.

If the current element is smaller than the top of the stack, what should we do?

A Ignore the current element

B Push the current element onto the stack

C Pop the top element from the stack

D Replace the top element with the current element

If the current element is smaller, we push it onto the stack because it might have a greater element later.

What value is assigned if no Next Greater Element exists for an element?

A 0

B The smallest element in the array

C -1

D The element itself

We assign -1 to indicate no greater element exists to the right.

What is the worst-case time complexity of the naive approach to find NGE without a stack?

A O(n²)

B O(n log n)

C O(n)

D O(log n)

The naive approach checks each element's right side, leading to O(n²) time.

Which data structure is best suited for solving the Next Greater Element problem efficiently?

A Array

B Queue

C Linked List

D Stack

A stack allows efficient tracking of elements waiting for their NGE.

Explain how the stack is used step-by-step in the Next Greater Element algorithm.

Think about how the stack helps remember elements waiting for their next bigger number.

Describe the difference in time complexity between the naive and stack-based Next Greater Element solutions.

Focus on how many times each element is processed.

Practice

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

easy

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

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

C. The last element in the array

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

Solution

1. Step 1: Understand the problem definition

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

2. Step 2: Identify the role of the stack

   The stack helps efficiently find this next greater element by storing candidates and popping smaller elements.

3. Final Answer:

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

4. Quick Check:

   Next Greater Element = first greater right element [OK]

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

Common Mistakes:

• Confusing next greater with next smaller element
• Looking to the left instead of right
• Thinking it sums elements instead of finding one

2. Which of the following C code snippets correctly initializes an empty stack for Next Greater Element problem?

easy

A. int stack[100]; int top = -1;

B. int stack[] = {0}; int top = 0;

C. int *stack; int top = NULL;

D. stack = new int[100]; top = -1;

Solution

1. Step 1: Check valid C array and top initialization

   int stack[100]; int top = -1; declares a fixed size array and sets top to -1 indicating empty stack.

2. Step 2: Identify invalid syntax or semantics in other options

   int stack[] = {0}; int top = 0; initializes top to 0 which means stack is not empty; int *stack; int top = NULL; uses NULL for int top which is invalid; stack = new int[100]; top = -1; uses 'new' which is C++ syntax, not C.

3. Final Answer:

   int stack[100]; int top = -1; -> Option A

4. Quick Check:

   Stack array + top = -1 means empty [OK]

Hint: Use array and top = -1 for empty stack in C [OK]

Common Mistakes:

• Using C++ 'new' keyword in C code
• Initializing top to 0 instead of -1
• Using pointer without allocation

3. What is the output of the Next Greater Element array for input [4, 5, 2, 25] using the stack method?

medium

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

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

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

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

Solution

1. Step 1: Process each element to find next greater

   For 4, next greater is 5; for 5, next greater is 25; for 2, next greater is 25; for 25, no greater element, so -1.

2. Step 2: Confirm output array

   The output array is [5, 25, 25, -1].

3. Final Answer:

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

4. Quick Check:

   Next greater elements match output [OK]

Hint: Check each element's right side for first bigger number [OK]

Common Mistakes:

• Assigning smaller or wrong next greater values
• Using -1 for elements that do have greater elements
• Confusing order of output

4. Identify the bug in this C code snippet for Next Greater Element using stack:

for (int i = 0; i < n; i++) {
  while (top != -1 && arr[stack[top]] < arr[i]) {
    result[stack[top]] = arr[i];
    top--;
  }
  stack[++top] = i;
}
while (top != -1) {
  result[stack[top]] = 0;
  top--;
}

medium

A. Using post-increment instead of pre-increment on stack index

B. Assigning 0 instead of -1 for elements with no greater element

C. Incorrect loop condition causing infinite loop

D. Not initializing top before loop

Solution

1. Step 1: Check final assignment for elements with no next greater

   The code assigns 0 instead of -1, which is incorrect as per problem definition.

2. Step 2: Verify other parts of code

   Stack index increment and loop conditions are correct; top is assumed initialized before.

3. Final Answer:

   Assigning 0 instead of -1 for elements with no greater element -> Option B

4. Quick Check:

   No greater element should be -1, not 0 [OK]

Hint: Use -1 for no next greater element, not 0 [OK]

Common Mistakes:

• Using 0 instead of -1 for no next greater
• Forgetting to initialize top
• Wrong increment operator on stack

5. Given the array [13, 7, 6, 12], what is the Next Greater Element array using the stack approach? Also, explain why the last element's next greater 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 for each element

   For 13, no greater element to right, so -1; for 7, next greater is 12; for 6, next greater is 12; for 12, no greater element, so -1.

2. Step 2: Explain last element's next greater

   The last element 12 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 has -1 as no elements to right [OK]

Common Mistakes:

• Assigning next greater to last element
• Mixing up next greater for middle elements
• Confusing output order