Next Greater Element Using Stack in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the stack as an empty array.

DSA Javascript

const stack = [1];

Drag options to blanks, or click blank then click option'

A{}

B[]

Cnull

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using {} which creates an object, not an array.

Using null or 0 which are not arrays.

In JavaScript, an empty array is created using []. This is used to implement the stack.

2fill in blank

medium

Complete the code to push the current element onto the stack.

DSA Javascript

stack.[1](nums[i]);

Drag options to blanks, or click blank then click option'

Apop

Bunshift

Cshift

Dpush

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop which removes elements instead of adding.

Using shift or unshift which operate on the start of the array.

The push() method adds one or more elements to the end of an array, which is how we add elements to the stack.

3fill in blank

hard

Fix the error in the while loop condition to check if the stack is not empty.

DSA Javascript

while (stack.[1] > 0 && nums[stack[stack.length - 1]] < nums[i]) {

Drag options to blanks, or click blank then click option'

Alength

Bsize

Ccount

Dlength()

Attempts:

3 left

💡 Hint

Common Mistakes

Using size or count which are not valid for arrays in JavaScript.

Using length() with parentheses which causes an error.

In JavaScript, arrays have a length property (without parentheses) to get the number of elements.

4fill in blank

hard

Fill both blanks to pop the top index from the stack and assign the next greater element.

DSA Javascript

const topIndex = stack.[1]();
result[topIndex] = nums[[2]];

Drag options to blanks, or click blank then click option'

Apop

Bpush

Ci

Dstack.length - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using push instead of pop to remove elements.

Using stack.length - 1 instead of i for the next greater element.

pop() removes the top element from the stack. The next greater element is nums[i], where i is the current index.

5fill in blank

hard

Fill all three blanks to complete the function that returns the next greater elements array.

DSA Javascript

function nextGreaterElement(nums) {
  const result = new Array(nums.length).fill(-1);
  const stack = [];
  for (let [1] = 0; [1] < nums.length; [1]++) {
    while (stack.length > 0 && nums[stack[stack.length - 1]] < nums[[2]]) {
      const topIndex = stack.pop();
      result[topIndex] = nums[[2]];
    }
    stack.[3]([1]);
  }
  return result;
}

Drag options to blanks, or click blank then click option'

Ai

Bj

Cpush

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using j instead of i for the loop variable.

Using pop instead of push to add elements to the stack.

The loop variable is i. We compare nums[stack top] with nums[i]. We push i onto the stack.

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 last element in the array

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

Solution

1. Step 1: Understand the problem goal

   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: Recognize the role of the stack

   A stack helps track elements waiting for their next greater element to appear on the right.

3. Final Answer:

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

4. Quick Check:

   Next Greater Element = first bigger right element [OK]

Hint: Look right for first bigger number using 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 is the correct way to initialize an empty stack in JavaScript for solving Next Greater Element?

easy

A. const stack = null;

B. const stack = {};

C. const stack = [];

D. const stack = 0;

Solution

1. Step 1: Identify stack data structure in JavaScript

   Stacks are commonly implemented using arrays in JavaScript, so initializing with [] is correct.

2. Step 2: Check other options

   { } is an object, null is no value, 0 is a number, none suitable for stack operations.

3. Final Answer:

   const stack = []; -> Option C

4. Quick Check:

   Stack = array [] for push/pop [OK]

Hint: Use array [] for stack in JavaScript [OK]

Common Mistakes:

• Using object {} instead of array
• Assigning null or number instead of array
• Not initializing stack before use

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

medium

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

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

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

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

Solution

1. Step 1: Find next greater for each element

   4's next greater is 5, 5's next greater is 25, 2's next greater is 25, 25 has none so -1.

2. Step 2: Write output array

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

3. Final Answer:

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

4. Quick Check:

   Next Greater Element for [4,5,2,25] = [5,25,25,-1] [OK]

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

Common Mistakes:

• Assigning smaller or equal numbers as next greater
• Using -1 for elements that do have greater elements
• Mixing order of output array

4. Given the code snippet below, what is the bug that prevents correct Next Greater Element output?

function nextGreater(arr) {
  const stack = [];
  const result = new Array(arr.length).fill(-1);
  for (let i = 0; i <= arr.length; i++) {
    while (stack.length && arr[i] > arr[stack[stack.length - 1]]) {
      const idx = stack.pop();
      result[idx] = arr[i];
    }
    stack.push(i);
  }
  return result;
}

medium

A. Loop condition should be i < arr.length, not i <= arr.length

B. Stack should be initialized with arr values, not empty

C. Result array should be filled with zeros, not -1

D. Push should add arr[i], not index i

Solution

1. Step 1: Check loop boundary

   The loop runs from i = 0 to i <= arr.length, which causes arr[i] to be undefined at i = arr.length, causing errors.

2. Step 2: Correct loop condition

   Change to i < arr.length to avoid out-of-bound access and fix logic.

3. Final Answer:

   Loop condition should be i < arr.length, not i <= arr.length -> Option A

4. Quick Check:

   Loop index must be within array length [OK]

Hint: Use i < arr.length to avoid undefined access [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Pushing values instead of indices to stack
• Filling result with wrong default values

5. You have an array [13, 7, 6, 12]. Using the Next Greater Element approach with a stack, what is the final output array?

hard

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

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

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

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

Solution

1. Step 1: Find next greater for each element

   13 has no greater element to the right, so -1. 7's next greater is 12. 6's next greater is 12. 12 has none, so -1.

2. Step 2: Check if any element has a greater element before it

   13 is greater than 7 and 6, so their next greater is 12, but 7's next greater is 12, not 13. 13 itself has no greater element.

3. Step 3: Confirm output array

   The output is [-1, 12, 12, -1].

4. Final Answer:

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

5. Quick Check:

   Next Greater Element for [13,7,6,12] = [-1,12,12,-1] [OK]

Hint: Check right side for first bigger number, use stack to track indices [OK]

Common Mistakes:

• Assigning previous greater 13 instead of next greater 12 for 7
• Confusing next greater with previous greater
• Mixing output order