The Wayback Machine - https://web.archive.org/web/20221004062659/https://www.geeksforgeeks.org/find-next-smaller-next-greater-array/
Skip to content
Related Articles

Related Articles

Find next Smaller of next Greater in an array

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 06 Jul, 2022
View Discussion
Improve Article
Save Article

Given array of integer, find the next smaller of next greater element of every element in array.

Note : Elements for which no greater element exists or no smaller of greater element exist, print -1.

Examples: 

Input : arr[] = {5, 1, 9, 2, 5, 1, 7}
Output:          2  2 -1  1 -1 -1 -1
Explanation :  
Next Greater ->      Right Smaller 
   5 ->  9             9 ->  2 
   1 ->  9             9 ->  2
   9 -> -1            -1 -> -1
   2 ->  5             5 ->  1
   5 ->  7             7 -> -1
   1 ->  7             7 -> -1
   7 -> -1            -1 -> -1 

Input  : arr[] = {4, 8, 2, 1, 9, 5, 6, 3}
Output :          2  5  5  5 -1  3 -1 -1

A simple solution is to iterate through all elements. For every element, find the next greater element of current element and then find right smaller element for current next greater element. Time taken of this solution is O(n2). 

An efficient solution takes O(n) time. Notice that it is the combination of Next greater element & next smaller element in array.

Let input array be 'arr[]' and size of array be 'n'
find next greatest element of every element 

 step 1 : Create an empty stack (S) in which we store the indexes
          and NG[] that is user to store the indexes of NGE
          of every element.

 step 2 : Traverse the array in reverse order 
            where i goes from (n-1 to 0)

        a) While S is nonempty and the top element of 
           S is smaller than or equal to 'arr[i]':
              pop S

        b) If S is empty 
             arr[i] has no greater element
             NG[i] = -1

        c) else we have next greater element
             NG[i] = S.top() // here we store the index of NGE

        d). push current element index in stack 
           S.push(i)

Find Right smaller element of every element      
    
  step 3 : create an array RS[] used to store the index of
           right smallest element 

  step 4 : we repeat step (1 & 2)  with little bit of
           modification in step 1 & 2 .
           they are :

          a). we use RS[] in place of NG[].

          b). In step (2.a)
              we pop element form stack S  while S is not
              empty or the top element of S is greater than 
              or equal to 'arr[i]'  

  step 5 . compute all RSE of NGE :

           where i goes from 0 to n-1 
           if NG[ i ] != -1 && RS[ NG [ i]] ! =-1
              print arr[RS[NG[i]]]
          else
              print -1

Below is the implementation of above idea

C++




// C++ Program to find Right smaller element of next
// greater element
#include<bits/stdc++.h>
using namespace std;
 
// function find Next greater element
void nextGreater(int arr[], int n, int next[], char order)
{
    // create empty stack
    stack<int> S;
 
    // Traverse all array elements in reverse order
    // order == 'G' we compute next greater elements of
    //              every element
    // order == 'S' we compute right smaller element of
    //              every element
    for (int i=n-1; i>=0; i--)
    {
        // Keep removing top element from S while the top
        // element is smaller than or equal to arr[i] (if Key is G)
        // element is greater than or equal to arr[i] (if order is S)
        while (!S.empty() &&
              ((order=='G')? arr[S.top()] <= arr[i]:
                           arr[S.top()] >= arr[i]))
            S.pop();
 
        // store the next greater element of current element
        if (!S.empty())
            next[i] = S.top();
 
        // If all elements in S were smaller than arr[i]
        else
            next[i] = -1;
 
        // Push this element
        S.push(i);
    }
}
 
// Function to find Right smaller element of next greater
// element
void nextSmallerOfNextGreater(int arr[], int n)
{
    int NG[n]; // stores indexes of next greater elements
    int RS[n]; // stores indexes of right smaller elements
 
    // Find next greater element
    // Here G indicate next greater element
    nextGreater(arr, n, NG, 'G');
 
    // Find right smaller element
    // using same function nextGreater()
    // Here S indicate right smaller elements
    nextGreater(arr, n, RS, 'S');
 
    // If NG[i] == -1 then there is no smaller element
    // on right side. We can find Right smaller of next
    // greater by arr[RS[NG[i]]]
    for (int i=0; i< n; i++)
    {
        if (NG[i] != -1 && RS[NG[i]] != -1)
            cout << arr[RS[NG[i]]] << " ";
        else
            cout<<"-1"<<" ";
    }
}
 
// Driver program
int main()
{
    int arr[] = {5, 1, 9, 2, 5, 1, 7};
    int n = sizeof(arr)/sizeof(arr[0]);
    nextSmallerOfNextGreater(arr, n);
    return 0;
}

Java



// Java Program to find Right smaller element of next
// greater element
import java.util.Stack;
public class Main {
    // function find Next greater element
    public static void nextGreater(int arr[], int next[], char order)
    {
        // create empty stack
        Stack<Integer> stack=new Stack<>();
   
        // Traverse all array elements in reverse order
        // order == 'G' we compute next greater elements of
        //              every element
        // order == 'S' we compute right smaller element of
        //              every element
        for (int i=arr.length-1; i>=0; i--)
        {
            // Keep removing top element from S while the top
            // element is smaller than or equal to arr[i] (if Key is G)
            // element is greater than or equal to arr[i] (if order is S)
            while (!stack.isEmpty() && ((order=='G')? arr[stack.peek()] <= arr[i]:arr[stack.peek()] >= arr[i]))
                stack.pop();
   
            // store the next greater element of current element
            if (!stack.isEmpty())
                next[i] = stack.peek();
   
            // If all elements in S were smaller than arr[i]
            else
                next[i] = -1;
   
            // Push this element
            stack.push(i);
        }
    }
 
    // Function to find Right smaller element of next greater
    // element
    public static void nextSmallerOfNextGreater(int arr[])
    {
        int NG[]=new int[arr.length]; // stores indexes of next greater elements
        int RS[]=new int[arr.length]; // stores indexes of right smaller elements
   
        // Find next greater element
        // Here G indicate next greater element
        nextGreater(arr, NG, 'G');
   
        // Find right smaller element
        // using same function nextGreater()
        // Here S indicate right smaller elements
        nextGreater(arr, RS, 'S');
   
        // If NG[i] == -1 then there is no smaller element
        // on right side. We can find Right smaller of next
        // greater by arr[RS[NG[i]]]
        for (int i=0; i< arr.length; i++)
        {
            if (NG[i] != -1 && RS[NG[i]] != -1)
                System.out.print(arr[RS[NG[i]]]+" ");
            else
                System.out.print("-1 ");
        }
    } 
 
    public static void main(String args[]) {
        int arr[] = {5, 1, 9, 2, 5, 1, 7}; 
        nextSmallerOfNextGreater(arr);
    }
}
//This code is contributed by Gaurav Tiwari
Python 3



# Python 3 Program to find Right smaller element of next
# greater element
  
# function find Next greater element
def nextGreater(arr, n, next, order):
 
    S = []
  
    # Traverse all array elements in reverse order
    # order == 'G' we compute next greater elements of
    #              every element
    # order == 'S' we compute right smaller element of
    #              every element
    for i in range(n-1,-1,-1):
 
        # Keep removing top element from S while the top
        # element is smaller than or equal to arr[i] (if Key is G)
        # element is greater than or equal to arr[i] (if order is S)
        while (S!=[] and (arr[S[len(S)-1]] <= arr[i]
        if (order=='G') else  arr[S[len(S)-1]] >= arr[i] )):
                
            S.pop()
  
        # store the next greater element of current element
        if (S!=[]):
            next[i] = S[len(S)-1]
  
        # If all elements in S were smaller than arr[i]
        else:
            next[i] = -1
  
        # Push this element
        S.append(i)
  
# Function to find Right smaller element of next greater
# element
def nextSmallerOfNextGreater(arr, n):
    NG = [None]*n  #  stores indexes of next greater elements
    RS = [None]*n  # stores indexes of right smaller elements
  
    # Find next greater element
    # Here G indicate next greater element
    nextGreater(arr, n, NG, 'G')
  
    # Find right smaller element
    # using same function nextGreater()
    # Here S indicate right smaller elements
    nextGreater(arr, n, RS, 'S')
  
    # If NG[i] == -1 then there is no smaller element
    # on right side. We can find Right smaller of next
    # greater by arr[RS[NG[i]]]
    for i in range(n):
        if (NG[i] != -1 and RS[NG[i]] != -1):
            print(arr[RS[NG[i]]],end=" ")
        else:
            print("-1",end=" ")
  
# Driver program
if __name__=="__main__":
    arr = [5, 1, 9, 2, 5, 1, 7]
    n = len(arr)
    nextSmallerOfNextGreater(arr, n)
 
# this code is contributed by ChitraNayal
C#



using System;
using System.Collections.Generic;
 
// C# Program to find Right smaller element of next
// greater element
public class GFG {
    // function find Next greater element
    public static void nextGreater(int []arr, int []next, char order)
    {
        // create empty stack
        Stack<int> stack=new Stack<int>();
     
        // Traverse all array elements in reverse order
        // order == 'G' we compute next greater elements of
        //             every element
        // order == 'S' we compute right smaller element of
        //             every element
        for (int i=arr.Length-1; i>=0; i--)
        {
            // Keep removing top element from S while the top
            // element is smaller than or equal to arr[i] (if Key is G)
            // element is greater than or equal to arr[i] (if order is S)
            while (stack.Count!=0 && ((order=='G')? arr[stack.Peek()] <= arr[i]:arr[stack.Peek()] >= arr[i]))
                stack.Pop();
     
            // store the next greater element of current element
            if (stack.Count!=0)
                next[i] = stack.Peek();
     
            // If all elements in S were smaller than arr[i]
            else
                next[i] = -1;
     
            // Push this element
            stack.Push(i);
        }
    }
 
    // Function to find Right smaller element of next greater
    // element
    public static void nextSmallerOfNextGreater(int []arr)
    {
        int []NG=new int[arr.Length]; // stores indexes of next greater elements
        int []RS=new int[arr.Length]; // stores indexes of right smaller elements
     
        // Find next greater element
        // Here G indicate next greater element
        nextGreater(arr, NG, 'G');
     
        // Find right smaller element
        // using same function nextGreater()
        // Here S indicate right smaller elements
        nextGreater(arr, RS, 'S');
     
        // If NG[i] == -1 then there is no smaller element
        // on right side. We can find Right smaller of next
        // greater by arr[RS[NG[i]]]
        for (int i=0; i< arr.Length; i++)
        {
            if (NG[i] != -1 && RS[NG[i]] != -1)
                Console.Write(arr[RS[NG[i]]]+" ");
            else
                Console.Write("-1 ");
        }
    }
 
    public static void Main() {
        int []arr = {5, 1, 9, 2, 5, 1, 7};
        nextSmallerOfNextGreater(arr);
    }
}
// This code is contributed by PrinciRaj1992
Javascript



<script>
// Javascript Program to find Right smaller element of next
// greater element
     
    // function find Next greater element
    function nextGreater(arr,next,order)
    {
     
        // create empty stack
        let stack = [];
         
        // Traverse all array elements in reverse order
        // order == 'G' we compute next greater elements of
        //              every element
        // order == 'S' we compute right smaller element of
        //              every element
        for (let i = arr.length - 1; i >= 0; i--)
        {
         
            // Keep removing top element from S while the top
            // element is smaller than or equal to arr[i] (if Key is G)
            // element is greater than or equal to arr[i] (if order is S)
            while (stack.length!=0 && ((order=='G')? arr[stack[stack.length-1]] <= arr[i] : arr[stack[stack.length-1]] >= arr[i]))
                stack.pop();
     
            // store the next greater element of current element
            if (stack.length != 0)
                next[i] = stack[stack.length - 1];
     
            // If all elements in S were smaller than arr[i]
            else
                next[i] = -1;
     
            // Push this element
            stack.push(i);
        }
    }
     
    // Function to find Right smaller element of next greater
    // element
    function nextSmallerOfNextGreater(arr)
    {
        let NG = new Array(arr.length); // stores indexes of next greater elements
        let RS = new Array(arr.length); // stores indexes of right smaller elements
        for(let i = 0; i < arr.length; i++)
        {
            NG[i] = 0;
            RS[i] = 0;
        }
         
        // Find next greater element
        // Here G indicate next greater element
        nextGreater(arr, NG, 'G');
     
        // Find right smaller element
        // using same function nextGreater()
        // Here S indicate right smaller elements
        nextGreater(arr, RS, 'S');
     
        // If NG[i] == -1 then there is no smaller element
        // on right side. We can find Right smaller of next
        // greater by arr[RS[NG[i]]]
        for (let i = 0; i < arr.length; i++)
        {
            if (NG[i] != -1 && RS[NG[i]] != -1)
                document.write(arr[RS[NG[i]]] + " ");
            else
                document.write("-1 ");
        }
    }
     
    // Driver code
    let arr = [5, 1, 9, 2, 5, 1, 7];
    nextSmallerOfNextGreater(arr);
     
    // This code is contributed by rag2127
</script>
Output
2 2 -1 1 -1 -1 -1 
Time complexity : O(n), where n is the size of the given array.
Auxiliary Space: O(n), where n is the size of the given array.
This article is contributed by Nishant_Singh(Pintu). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org.

My Personal Notes
arrow_drop_up
Previous
Find maximum difference between nearest left and right smaller elements
Next

Find maximum equal sum of every three stacks
Recommended Articles
Page :
Delete array elements which are smaller than next or become smaller
22, Mar 18
For all Array elements find Product of Sum of all smaller and Sum of all greater elements
06, Apr 22
Find the element before which all the elements are smaller than it, and after which all are greater
24, Oct 15
Size of smallest subarray to be removed to make count of array elements greater and smaller than K equal
26, Aug 20
Minimize array sum by replacing greater and smaller elements of pairs by half and double of their values respectively atmost K times
11, Nov 20
Count elements in Array having strictly smaller and strictly greater element present
26, Jan 22
Rearrange array such that even index elements are smaller and odd index elements are greater
08, Oct 17
Modify given array by reducing each element by its next smaller element
02, Dec 20
Count smaller elements on right side and greater elements on left side using Binary Index Tree
09, Aug 19
Find the next greater element in a Circular Array | Set 2
02, Dec 20
Find next greater number formed with exactly two unique digits for each Array element
16, Nov 21
Find the next greater element in a Circular Array
23, Jun 20
Next Smaller Element
01, Sep 18
C++ Program To Find Next Greater Element
17, Nov 21
C Program To Find Next Greater Element
17, Nov 21
Java Program To Find Next Greater Element
17, Nov 21
Php Program To Find Next Greater Element
17, Nov 21
Javascript Program To Find Next Greater Element
17, Nov 21
Find next greater number with same set of digits
17, Jul 14
Elements greater than the previous and next element in an Array
03, Apr 19
Count of Array elements greater than all elements on its left and next K elements on its right
05, Aug 20
Count of numbers in given Array greater than next K elements
08, Dec 21
Maximize value obtained in Array by jumping to the next consecutive greater
19, May 22
Next Greater Element (NGE) for every element in given Array
17, Mar 11
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!