# Smallest Greater Element on Right Side

Last Updated : 14 Mar, 2023

3Given an array of distinct elements, print the closest greater element for every element. The closest greater element for an element x is the smallest element on the right side of x in array which is greater than x. Elements for which no greater element exist, consider next greater element as -1.

Examples:

```Input: arr[] = {4, 5, 2, 25}
Output:
Element       NGE
4      -->   5
5      -->   25
2      -->   25
25     -->   -1

Input: arr[] = {4, 10, 7}
Output:
Element       NGE
4       -->  7
10      -->   -1
7       -->   -1```

Approach: In this post, we will be discussing how to find the Next Greater Element using C++ STL(set).

Finding the smallest greater element on the right side will be like finding the first greater element of the current element in a list that is sorted.
Consider example 1, The sorted list would look like 2, 4, 5, 25.

Here for element 4, the greater element is 5 as it is next to it, so we print 5 and remove 4 because it would not be greater to the other elements since it is no longer on anyone’s right.
Similarly, for 5 it is 25 and we remove 5 from the list, as 5 will not be on the right side of 2 or 25, so it can be deleted.

Given below are the steps to find the Next Greater Element of every index element.

• Insert all the elements in a Set, it will store all the elements in an increasing order.
• Iterate on the array of elements, and for each index, find the upper_bound of the current index element. The upper_bound() returns an iterator which can point to the following position.
1. If the iterator is pointing to a position past the last element, then there exists no NGE to the current index element.
2. If the iterator points to a position referring to an element, then that element is the NGE to the current index element.
• Find the position of current index element at every traversal and remove it from the set using >lower_bound() and erase() functions of set.

Implementation:

## C++

 `// C++ program to print the ` `// NGE's of array elements using ` `// C++ STL ` `#include ` `using` `namespace` `std; `   `// Function to print the NGE ` `void` `printNGE(``int` `a[], ``int` `n) ` `{ `   `    ``set<``int``> ms; `   `    ``// insert in the multiset container ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``ms.insert(a[i]); `   `    ``cout << ``"Element "` `        ``<< ``"NGE"``; `   `    ``// traverse for all array elements ` `    ``for` `(``int` `i = 0; i < n; i++) { `   `        ``// find the upper_bound in set ` `        ``auto` `it = ms.upper_bound(a[i]); `   `        ``// if points to the end, then ` `        ``// no NGE of that element ` `        ``if` `(it == ms.end()) { ` `            ``cout << ``"\n "` `<< a[i] ` `                ``<< ``" ----> "` `<< -1; ` `        ``} `   `        ``// print the element at that position ` `        ``else` `{ ` `            ``cout << ``"\n "` `<< a[i] ` `                ``<< ``" ----> "` `<< *it; ` `        ``} `   `        ``// find the first occurrence of ` `        ``// the index element and delete it ` `        ``it = ms.lower_bound(a[i]); `   `        ``// delete one occurrence ` `        ``// from the container ` `        ``ms.erase(it); ` `    ``} ` `} `   `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = { 4, 5, 2, 25 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); `   `    ``// Function call to print the NGE ` `    ``printNGE(a, n); ` `    ``return` `0; ` `} `

## Java

 `// C++ program to print the` `// NGE's of array elements using` `import` `java.util.TreeSet;`   `class` `Geeks {`   `    ``// Function to print the NGE` `    ``static` `void` `printNGE(``int``[] a, ``int` `n)` `    ``{`   `        ``// Tree Set is an ordered set used to` `        ``// store elements in a sorted manner` `        ``TreeSet t = ``new` `TreeSet<>();`   `        ``// Adding elements into the set` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``t.add(a[i]);`   `        ``System.out.println(``"ELEMENT     NGE"``);`   `        ``for` `(``int` `i = ``0``; i < n; i++) {`   `            ``// If the elements does not have an upper bound` `            ``// or an element greater than it,` `            ``// higher method of TreeSet class will return NULL` `            ``if` `(t.higher(a[i]) == ``null``)` `                ``System.out.println(a[i] + ``" ----> "` `                                   ``+ ``"-1"``);`   `            ``// Otherwise print the upper bound of that element` `            ``else` `                ``System.out.println(a[i] + ``" ----> "` `+ t.higher(a[i]));`   `            ``// Remove the current element from the set` `            ``t.remove(a[i]);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `a[] = { ``4``, ``5``, ``2``, ``25` `};` `        ``int` `n = a.length;`   `        ``printNGE(a, n);` `    ``}` `}`

## Python3

 `# Python3 program to print the` `# NGE's of array elements` `from` `bisect ``import` `bisect_right as upper_bound, \` `                   ``bisect_left as lower_bound`   `# Function to print the NGE` `def` `printNGE(a: ``list``, n):` `    ``ms ``=` `set``()`   `    ``# insert in the multiset container` `    ``for` `i ``in` `range``(n):` `        ``ms.add(a[i])`   `    ``print``(``"Element NGE"``, end ``=` `"")`   `    ``# Required because Python sets` `    ``# are not sorted` `    ``new_arr ``=` `list``(ms)` `    ``new_arr.sort()`   `    ``# traverse for all array elements` `    ``for` `i ``in` `range``(n):`   `        ``# find the upper_bound in set` `        ``it ``=` `upper_bound(new_arr, a[i])`   `        ``# if points to the end, then` `        ``# no NGE of that element` `        ``if` `(it ``=``=` `len``(new_arr)):` `            ``print``(``"\n %d ----> -1"` `%` `a[i], end ``=` `"")`   `        ``# print the element at that position` `        ``else``:` `            ``print``(``"\n %d ----> %d"` `%` `(a[i], ` `                    ``new_arr[it]), end ``=` `"")`   `        ``# find the first occurrence of` `        ``# the index element and delete it` `        ``it ``=` `lower_bound(new_arr, a[i])`   `        ``# delete one occurrence` `        ``# from the container` `        ``new_arr.remove(new_arr[it])`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `[``4``, ``5``, ``2``, ``25``]` `    ``n ``=` `len``(a)`   `    ``# Function call to print the NGE` `    ``printNGE(a, n)`   `# This code is contributed by` `# sanjeev2552`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `Geeks` `{` `    ``// Function to print the NGE ` `    ``static` `void` `printNGE(``int``[] a, ``int` `n)` `    ``{` `        ``// insert in the multiset container of array a` `        ``SortedSet<``int``> s = ``new` `SortedSet<``int``>(a);`   `        ``Console.WriteLine(``"Element NGE"``);` `            `  `        ``// traverse for all array elements ` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``SortedSet<``int``>.Enumerator enumr = s.GetViewBetween(a[i] + 1, ``int``.MaxValue).GetEnumerator();` `                `  `            `  `            ``// if points to the end, then ` `            ``// no NGE of that element ` `            ``if` `(!enumr.MoveNext()) {` `                ``Console.WriteLine(\$``"{a[i]} ----> -1"``);` `            ``}` `            ``// print the element at that position ` `            ``else` `{` `                ``Console.WriteLine(\$``"{a[i]} ----> {enumr.Current}"``);` `            ``}` `            `  `            ``// delete one occurrence ` `            ``// from the container ` `            ``s.Remove(a[i]);` `        ``}` `    ``}` `        `  `        `  `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        `  `        ``int``[] a = { 4, 5, 2, 25 };` `        ``int` `n = a.Length;` `        `  `        ``// Function call to print the NGE ` `        ``printNGE(a, n);` `    ``}` `}`   `// This code is contributed by codebraxnzt`

## Javascript

 ``

Output

```Element NGE
4 ----> 5
5 ----> 25
2 ----> 25
25 ----> -1```

Complexity Analysis:

• Time Complexity: O(N*logN), as we are using a loop to traverse N times and in each traversal we are inserting to the set which will cost us logN time.
• Auxiliary Space: O(N), as we are using extra space for set ms.