Java Program To Find Next Greater Element
Last Updated :
17 Dec, 2021
Given an array, print the Next Greater Element (NGE) for every element. The Next greater Element for an element x is the first greater element on the right side of x in the array. Elements for which no greater element exist, consider the next greater element as -1.
Examples:
- For an array, the rightmost element always has the next greater element as -1.
- For an array that is sorted in decreasing order, all elements have the next greater element as -1.
- For the input array [4, 5, 2, 25], the next greater elements for each element are as follows.
Element NGE
4 --> 5
5 --> 25
2 --> 25
25 --> -1
d) For the input array [13, 7, 6, 12}, the next greater elements for each element are as follows.
Element NGE
13 --> -1
7 --> 12
6 --> 12
12 --> -1
Method 1 (Simple)
Use two loops: The outer loop picks all the elements one by one. The inner loop looks for the first greater element for the element picked by the outer loop. If a greater element is found then that element is printed as next, otherwise, -1 is printed.
Below is the implementation of the above approach:
Java
// Simple Java program to print next
// greater elements in a given array
class Main
{
/* prints element and NGE pair for
all elements of arr[] of size n */
static void printNGE(int arr[], int n)
{
int next, i, j;
for (i=0; i<n; i++)
{
next = -1;
for (j = i+1; j<n; j++)
{
if (arr[i] < arr[j])
{
next = arr[j];
break;
}
}
System.out.println(arr[i]+" -- "+next);
}
}
public static void main(String args[])
{
int arr[]= {11, 13, 21, 3};
int n = arr.length;
printNGE(arr, n);
}
}
Output11 -- 13
13 -- 21
21 -- -1
3 -- -1
Time Complexity: O(N2)
Auxiliary Space: O(1)
Method 2 (Using Stack)
- Push the first element to stack.
- Pick rest of the elements one by one and follow the following steps in loop.
- Mark the current element as next.
- If stack is not empty, compare top element of stack with next.
- If next is greater than the top element, Pop element from stack. next is the next greater element for the popped element.
- Keep popping from the stack while the popped element is smaller than next. next becomes the next greater element for all such popped elements.
- Finally, push the next in the stack.
- After the loop in step 2 is over, pop all the elements from the stack and print -1 as the next element for them.
Below image is a dry run of the above approach:
Below is the implementation of the above approach:
Java
// Java program to print next
// greater element using stack
public class NGE {
static class stack {
int top;
int items[] = new int[100];
// Stack functions to be used by printNGE
void push(int x)
{
if (top == 99)
{
System.out.println("Stack full");
}
else
{
items[++top] = x;
}
}
int pop()
{
if (top == -1)
{
System.out.println("Underflow error");
return -1;
}
else {
int element = items[top];
top--;
return element;
}
}
boolean isEmpty()
{
return (top == -1) ? true : false;
}
}
/* prints element and NGE pair for
all elements of arr[] of size n */
static void printNGE(int arr[], int n)
{
int i = 0;
stack s = new stack();
s.top = -1;
int element, next;
/* push the first element to stack */
s.push(arr[0]);
// iterate for rest of the elements
for (i = 1; i < n; i++)
{
next = arr[i];
if (s.isEmpty() == false)
{
// if stack is not empty, then
// pop an element from stack
element = s.pop();
/* If the popped element is smaller than
next, then a) print the pair b) keep
popping while elements are smaller and
stack is not empty */
while (element < next)
{
System.out.println(element + " --> "
+ next);
if (s.isEmpty() == true)
break;
element = s.pop();
}
/* If element is greater than next, then
push the element back */
if (element > next)
s.push(element);
}
/* push next to stack so that we can find next
greater for it */
s.push(next);
}
/* After iterating over the loop, the remaining
elements in stack do not have the next greater
element, so print -1 for them */
while (s.isEmpty() == false)
{
element = s.pop();
next = -1;
System.out.println(element + " -- " + next);
}
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 11, 13, 21, 3 };
int n = arr.length;
printNGE(arr, n);
}
}
// Thanks to Rishabh Mahrsee for contributing this code
Output11 --> 13
13 --> 21
3 --> -1
21 --> -1
Time Complexity: O(N)
Auxiliary Space: O(N)
The worst case occurs when all elements are sorted in decreasing order. If elements are sorted in decreasing order, then every element is processed at most 4 times.
- Initially pushed to the stack.
- Popped from the stack when next element is being processed.
- Pushed back to the stack because the next element is smaller.
- Popped from the stack in step 3 of the algorithm.
How to get elements in the same order as input?
The above approach may not produce output elements in the same order as the input. To achieve the same order, we can traverse the same in reverse order
Below is the implementation of the above approach:
Java
// A Stack based Java program to find next
// greater element for all array elements
// in same order as input.
import java.util.Stack;
class NextGreaterElement {
static int arr[] = { 11, 13, 21, 3 };
/* prints element and NGE pair for all
elements of arr[] of size n */
public static void printNGE()
{
Stack<Integer> s = new Stack<>();
int nge[] = new int[arr.length];
// iterate for rest of the elements
for (int i = arr.length - 1; i >= 0; i--)
{
/* if stack is not empty, then
pop an element from stack.
If the popped element is smaller
than next, then
a) print the pair
b) keep popping while elements are
smaller and stack is not empty */
if (!s.empty())
{
while (!s.empty()
&& s.peek() <= arr[i])
{
s.pop();
}
}
nge[i] = s.empty() ? -1 : s.peek();
s.push(arr[i]);
}
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i] +
" --> " + nge[i]);
}
/* Driver Code */
public static void main(String[] args)
{
// NextGreaterElement nge = new
// NextGreaterElement();
printNGE();
}
}
Output11 ---> 13
13 ---> 21
21 ---> -1
3 ---> -1
Time Complexity: O(N)
Auxiliary Space: O(N)
Please refer complete article on
Next Greater Element for more details!
Similar Reads
Java Program to Find Largest Element in an Array
Finding the largest element in an array is a common programming task. There are multiple approaches to solve it. In this article, we will explore four practical approaches one by one to solve this in Java.Example Input/Output:Input: arr = { 1, 2, 3, 4, 5}Output: 5Input: arr = { 10, 3, 5, 7, 2, 12}Ou
4 min read
Java Program to Get Elements By Index from LinkedHashSet
LinkedHashSet is a pre-defined class in Java that is similar to HashSet. Unlike HashSet In LinkedHashSet insertion order is preserved. In order to get element by Index from LinkedHashSet in Java, we have multiple ways.Illustration:Input : 2, 3, 4, 2, 7;Processing : index = 4;Output : Element at inde
4 min read
Java Program to Get First or Last Elements from HashSet
The HashSet class implements the Set interface, backed by a hash table which is actually a HashMap instance. There is no guarantee made for the iteration order of the set which means that the class does not guarantee the constant order of elements over time. This class permits the null element. The
3 min read
Iterate Over Vector Elements in Java
Vector is like the dynamic array which can grow or shrink its size. Unlike array, we can store n-number of elements in it as there is no size limit. We can iterate over vector by the following ways: Simple for-loopEnhanced for-loopIteratorsEnumeration interface Method 1: Simple for-loop The idea is
4 min read
Java Program to Find closest number in array
Given an array of sorted integers. We need to find the closest value to the given number. Array may contain duplicate values and negative numbers. Examples: Input : arr[] = {1, 2, 4, 5, 6, 6, 8, 9} Target number = 11 Output : 9 9 is closest to 11 in given array Input :arr[] = {2, 5, 6, 7, 8, 8, 9};
4 min read
Find the last element of a Stream in Java
Given a stream containing some elements, the task is to get the last element of the Stream in Java.Example:Input: Stream={“Geek_Firstâ€, “Geek_2â€, “Geek_3â€, “Geek_4â€, “Geek_Lastâ€}Output: Geek_LastInput: Stream={1, 2, 3, 4, 5, 6, 7}Output: 7Methods to Find the Last Element of a Stream in JavaThere are
4 min read
Java Program to Search an Element in a Linked List
Prerequisite: LinkedList in java LinkedList is a linear data structure where the elements are not stored in contiguous memory locations. Every element is a separate object known as a node with a data part and an address part. The elements are linked using pointers or references. Linked Lists are pre
5 min read
Java Program to Find the Index of the TreeSet Element
Unlike the List classes like ArrayList or a LinkedList, the TreeSet class does not allow accessing elements using the index. There are no direct methods to access the TreeSet elements using the index and thus finding an index of an element is not straightforward. Methods: There are primarily three s
6 min read
Java Program to Increment All Element of an Array by One
Given the array, the task is to increment each element of the array by 1. Complete traversal is required for incrementing all the elements of an array. An optimized way to complete a given task is having time complexity as O(N). Examples: Input : arr1[] = {50, 25, 32, 12, 6, 10, 100, 150} Output: ar
4 min read
Java Program to Get the Maximum Element From a Vector
Prerequisite: Vectors in Java Why We Use Vector? Till now, we have learned two ways for declaring either with a fixed size of array or size enter as per the demand of the user according to which array is allocated in memory. int Array_name[Fixed_size] ; int array_name[variable_size] ; Both ways we l
4 min read