Open In App

Smallest Greater Element on Right Side

Improve
Improve
Like Article
Like
Save
Share
Report

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 <bits/stdc++.h>
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<Integer> 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




<script>
// Javascript program to print the
// NGE's of array elements using
 
    // Function to print the NGE
    function printNGE(a , n) {
 
        // Tree Set is an ordered set used to
        // store elements in a sorted manner
        var t = new Set();
 
        // Adding elements into the set
        for (var i = 0; i < n; i++)
            t.add(a[i]);
 
        document.write("ELEMENT     NGE<br/>");
 
        for (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 (upper_bound(t,a[i]) == null)
                document.write(a[i] + " ----> " + "-1"+"<br/>");
 
            // Otherwise print the upper bound of that element
            else
                document.write(a[i] + " ----> " + upper_bound(t,a[i])+"<br/>");
 
            // Remove the current element from the set
            t.delete(a[i]);
        }
    }
    function upper_bound(s, val)
    {
        let temp = [...s];
        temp.sort((a, b) => b - a);
        return temp[temp.indexOf(val) + 1];
    }
     
    // Driver code
        var a = [ 4, 5, 2, 25 ];
        var n = a.length;
 
        printNGE(a, n);
 
// This code contributed by Rajput-Ji
</script>


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.


Last Updated : 14 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads