Next Greater Element in Java

In an array, the next greater element is the element that is the nearest as well as the greater than the current element. Also, the next greater element should come after the current element. The task is to return the next greater element for every element present in an integer array. If the next greater element does not exist for an element of the array, then for that element, we will print the appropriate message. For simplicity, we will assume that every element of the input array is non-negative. Let's understand with the help of an example.

Input:

arr[] = {14, 16, 9, 90, 99, 2, 6, 19, 4}

Output with Explanation:

Element	Next Greater Element (NGE)	Reason
14	16	The element 16 is immediately next to 14. Also, 16 is greater than 14.
16	90	Elements that are greater than 16 are 90 and 99. However, we will pick 90 as the element 90 is the nearest to the element 16.
9	90	The element 90 is immediately next to 9. Also, 90 is greater than 9.
90	99	The element 99 is immediately next to 90. Also, 99 is greater than 90.
99	Not found	There is no any element that comes after the element 99 and is greater than 99.
2	6	The element 6 is immediately next to 2. Also, 6 is greater than 2.
6	19	The element 19 is immediately next to 6. Also, 19 is greater than 6.
19	Not found	There is no any element that comes after the element 19 and is greater than 19.
4	Not found	There is no any element that comes after the element 4.

Note 1: For the last element, the next greater element will always be -1, as after the last element, we do not have any other element.

Note 2: For an input array that is sorted in non-increasing order, the value of the next greater element will always be -1. It is because all the next elements from the current element will always be less than or equal to the current element, as the elements are arranged in the non-decreasing order.

For example:

Input:

arr[] = {89, 60, 58, 45, 39, 36, 20}

Output with Explanation:

The next greater element of all the elements of the input array is -1.

For the number 89 there is no element that comes after 89 and is greater than 89.

For the number 60 there is no element that comes after 60 and is greater than 60.

A similar explanation can be given for the other elements too.

Approach

There are two approaches to solve the next greater element problem: one is the naïve approach, and the other is using a stack. Let's start with the naïve one.

Native Approach

The naïve approach is simple. One has to use two for-loops. The outer loop is for picking up the element, and the inner loop is for comparing the elements with the picked element (current element). The inner loop terminates immediately when a greater element (after comparing with the current element) is found. Observe the following program.

FileName: NGE.java

public class NGE
{

// main method
public static void main(String argvs[])
{
// input array
int arr[] = new int[]{14, 16, 9, 90, 99, 2, 6, 19, 4};

// computing size of the input array
int size = arr.length;

System.out.println("The input array is: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println("\n");

for(int i = 0; i < size; i++)
{
int temp = -1;
for(int j = i + 1; j < size; j++)
{
    if(arr[j] > arr[i])
    {
       temp = arr[j]; 
       break;
    }
    
}
if(temp != -1)
{
System.out.println("The next greater element for the element " + arr[i] + " is: " + temp);
}
else
{
System.out.println("The next greater element for the element " + arr[i] + " does not exist. ");
}
}
}
}

Output:

The input array is: 
14 16 9 90 99 2 6 19 4 

The next greater element for the element 14 is: 16
The next greater element for the element 16 is: 90
The next greater element for the element 9 is: 90
The next greater element for the element 90 is: 99
The next greater element for the element 99 does not exist. 
The next greater element for the element 2 is: 6
The next greater element for the element 6 is: 19
The next greater element for the element 19 does not exist. 
The next greater element for the element 4 does not exist.

Time Complexity: The above program is using two nested for-loops. Therefore, the time complexity of the above program is O(n²), where n is the total number of elements present in the input array.

Space Complexity: The program is not using any extra space. Therefore, the space complexity of the above program is O(1).

Optimized Approach: Using Stack

Algorithm

Step 1: In the stack, push the first element.

Step 2: Select the remaining elements one by one and repeat the mentioned sub-steps in the loop.

Treat the current element as the next.
If the stack is not vacant, compare the top element of the stack with the next.
If the next is larger than the top element, then pop the element from the stack. next is the next larger element for the element that is popped.
If the popped element is smaller than the next, keep popping elements from the stack. For all of such popped elements, the next becomes the next larger element.

Step 3: Eventually, the next in the stack is pushed.

Step 4: After the loop mentioned in step 2 is finished, keep popping from stack all the remaining elements, and display -1 for them as the next element.

FileName: NGE1.java

public class NGE1 
{
// internal class that imitates a stack
public class Stk 
{
int t;
int store[] = new int[100];

// Stack method that is being used by the displayNGE() method
void push(int y)
{
    if (t == 99)
    {
        System.out.println("Stack is full");
    }
    else
    {
        t = t + 1;
        store[t] = y;
    }
}

int pop()
{
    if (t == -1)
    {
        System.out.println("the stack is underflow");
        return -1;
    }
    else 
    {
        int ele = store[t];
        t = t - 1;
        return ele;
    }
}

boolean isVacant()
{
    return (t != -1) ? false : true;
}
}

// displays the pair of elements and the next greater element for
// all of the elements of the arr[] of the size s
public void displayNGE(int arr[], int s)
{
int j = 0;
Stk stk = new Stk();
stk.t = -1;
int ele;
int next;

/* push the first element to the stack */
stk.push(arr[0]);

// loop over for the rest of elements
for (j = 1; j < s; j++)
{
    next = arr[j];

    if (stk.isVacant() == false)
    {

        // if the stack is not empty, then
        // pop the element from stack
        ele = stk.pop();

        // If the popped element is smaller than
        //  the  next, then a) print the poppped element and the next greater element
        // b) keep popping from the stack until 
        // the elements are smaller andthe stack is not vacant
        while (ele < next)
        {
            System.out.println("The next greater element for the element " + ele + " is: " + next);
            if (stk.isVacant() == true)
            {
                break;
            }
            ele = stk.pop();
        }

        // If the ele is larger than the next, then
        //   push back the element back
        if (ele > next)
        {
            stk.push(ele);
        }
    }

    // push the next to the stack stk. hus, we can look for the next
    // larger element for it 
    stk.push(next);
}

// The next greater element does not exist for the left elements
// in the stack stk, so we shall display the message accordingly 
// for all these left elements
while (stk.isVacant() == false)
{
    ele = stk.pop();
    System.out.println("The next greater element for the element " + ele + " does not exist.");
}
}

// main method
public static void main(String argvs[])
{

// creating an object of the class NGE1
NGE1 obj = new NGE1();

// input array
int arr[] = new int[]{14, 16, 9, 90, 99, 2, 6, 19, 4};

// computing size of the input array
int size = arr.length;

System.out.println("The input array is: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println("\n");

obj.displayNGE(arr, size);

}
}

Output:

The input array is: 
14 16 9 90 99 2 6 19 4 

The next greater element for the element 14 is: 16
The next greater element for the element 9 is: 90
The next greater element for the element 16 is: 90
The next greater element for the element 90 is: 99
The next greater element for the element 2 is: 6
The next greater element for the element 6 is: 19
The next greater element for the element 4 does not exist.
The next greater element for the element 19 does not exist.
The next greater element for the element 99 does not exist.

Time Complexity: The time complexity of the above program is O(n), where n is the total number of elements present in the array.

Space Complexity: The space complexity of the above program is O(n), where n is the total number of elements present in the array.

We see that the order in which numbers are coming in the output is not the same in the input array. To maintain the order, have to traverse in the reverse order. Observe the following program.

FileName: NGE2.java

// important import statement
import java.util.Stack;

public class NGE2
{

// displays the pair of elements and the next greater element for
// all of the elements of the arr[] of the size s
public void displayNGE(int a[], int s)
{
Stack<Integer> stk = new Stack<Integer>();
int nextGrInt[] = new int[a.length];

// iterate over the remaining elements
for (int j = a.length - 1; j >= 0; j--)
{
    // if the stack is not vacant, then pop
    // an element from the stack.
    // If the element popped is less
    // than the next, then first display the 
    // element and the next greater element
    // and secondly keep popping the element 
    // till the elements are empty and the stack
    // is not vacant
    if (!stk.empty())
    {
        while (!stk.empty()
               && stk.peek() <= a[j])
        {
            stk.pop();
        }
    }
    nextGrInt[j] = stk.empty() ? -1 : stk.peek();
    stk.push(a[j]);
}
for (int j = 0; j < a.length; j++)

    if(nextGrInt[j] != -1)
    {
    System.out.println("The next greater element for the element " + a[j] + " is: " + nextGrInt[j]);
    }
    else
    {
    System.out.println("The next greater element for the element " + a[j] + " does not exist.");
    }
}


// main method
public static void main(String argvs[])
{

// creating an object of the class NGE2
NGE2 obj = new NGE2();

// input array
int arr[] = new int[]{14, 16, 9, 90, 99, 2, 6, 19, 4};

// computing size of the input array
int size = arr.length;

System.out.println("The input array is: ");
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println("\n");


obj.displayNGE(arr, size);


}
}

Output:

The input array is: 
14 16 9 90 99 2 6 19 4 

The next greater element for the element 14 is: 16
The next greater element for the element 16 is: 90
The next greater element for the element 9 is: 90
The next greater element for the element 90 is: 99
The next greater element for the element 99 does not exist.
The next greater element for the element 2 is: 6
The next greater element for the element 6 is: 19
The next greater element for the element 19 does not exist.
The next greater element for the element 4 does not exist.

Time Complexity: The time complexity of the above program is O(n), where n is the total number of elements present in the array.

Space Complexity: The space complexity of the above program is O(n), where n is the total number of elements present in the array.

Next TopicStar Numbers in Java

← prev next →