# Find the next greater element in a Circular Array | Set 2

• Last Updated : 26 Aug, 2021

Given a circular array arr[] consisting of N integers, the task is to print the Next Greater Element for every element of the circular array. Elements for which no greater element exist, print “-1”.

Examples:

Input: arr[] = {5, 6, 7}
Output: 6 7 -1
Explanation: The next greater element for every array element are as follows:
For arr (= 5) -> 6
For arr (= 6) -> 7
For arr (= 7), no greater element is present in the array. Therefore, print -1.

Input: arr[] = {4, -2, 5, 3}
Output: 5 5 -1 4
Explanation: The next greater element for every array element are as follows:
For arr (= 4) -> 5
For arr (= -2) -> 5
For arr (= 5), no greater element is present in the array. Therefore, print -1.
For arr (= 3) -> 4

Naive Approach: The simplest approach to solve this problem is discussed in the previous post of this article.

Time Complexity: O(N2)
Auxiliary Space: O(N)

Alternate Approach: Refer to the previous post of this article for space-optimization of the naive approach.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use the concept of Next Greater Element which uses a Stack data structure. Follow the steps below to solve the problem:

• Initialize a stack to store the indices of the array and an array nge[] of size N which stores the next greater element for each array element.
• Traverse the array and for each index, perform the following:
• After a single traversal of N elements, the stack contains the elements which do not have a next greater element till the (N – 1)th index. As the array is circular, consider all the elements from the 0th index again and find the next greater element of the remaining elements.
• Since the array is traversed 2 times, it is better to use i % N instead of i.
• After completing the above steps, print the array nge[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the NGE for the``// given circular array arr[]``void` `printNGE(``int``* arr, ``int` `n)``{``    ``// Initialize stack and nge[] array``    ``stack<``int``> s;``    ``int` `nge[n], i = 0;` `    ``// Initialize nge[] array to -1``    ``for` `(i = 0; i < n; i++) {``        ``nge[i] = -1;``    ``}``    ``i = 0;` `    ``// Traverse the array``    ``while` `(i < 2 * n) {` `        ``// If stack is not empty and``        ``// current element is greater``        ``// than top element of the stack``        ``while` `(!s.empty()``               ``&& arr[i % n] > arr[s.top()]) {` `            ``// Assign next greater element``            ``// for the top element of the stack``            ``nge[s.top()] = arr[i % n];` `            ``// Pop the top element``            ``// of the stack``            ``s.pop();``        ``}` `        ``s.push(i % n);``        ``i++;``    ``}` `    ``// Print the nge[] array``    ``for` `(i = 0; i < n; i++) {``        ``cout << nge[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, -2, 5, 8 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``printNGE(arr, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the NGE for the``// given circular array arr[]``static` `void` `printNGE(``int` `arr[], ``int` `n)``{``    ` `    ``// Initialize stack and nge[] array``    ``Stack s = ``new` `Stack<>();``    ``int` `nge[] = ``new` `int``[n];``    ``int` `i = ``0``;` `    ``// Initialize nge[] array to -1``    ``for``(i = ``0``; i < n; i++)``    ``{``        ``nge[i] = -``1``;``    ``}``    ``i = ``0``;` `    ``// Traverse the array``    ``while` `(i < ``2` `* n)``    ``{``        ` `        ``// If stack is not empty and``        ``// current element is greater``        ``// than top element of the stack``        ``while` `(!s.isEmpty() &&``               ``arr[i % n] > arr[s.peek()])``        ``{``            ` `            ``// Assign next greater element``            ``// for the top element of the stack``            ``nge[s.peek()] = arr[i % n];``            ` `            ``// Pop the top element``            ``// of the stack``            ``s.pop();``        ``}``        ``s.push(i % n);``        ``i++;``    ``}``    ` `    ``// Print the nge[] array``    ``for``(i = ``0``; i < n; i++)``    ``{``        ``System.out.print(nge[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``4``, -``2``, ``5``, ``8` `};``    ``int` `N = arr.length;` `    ``// Function Call``    ``printNGE(arr, N);``}``}` `// This code is contributed by yashbeersingh42`

## Python3

 `# Python3 program for the above approach` `# Function to find the NGE for the``# given circular array arr[]``def` `printNGE(arr, n) :``    ` `    ``# create stack list``    ``s ``=` `[];``    ` `    ``# Initialize nge[] array to -1``    ``nge ``=` `[``-``1``] ``*` `n;` `    ``i ``=` `0``;` `    ``# Traverse the array``    ``while` `(i < ``2` `*` `n) :` `        ``# If stack is not empty and``        ``# current element is greater``        ``# than top element of the stack``        ``while` `(``len``(s) !``=` `0` `and` `arr[i ``%` `n] > arr[s[``-``1``]]) :` `            ``# Assign next greater element``            ``# for the top element of the stack``            ``nge[s[``-``1``]] ``=` `arr[i ``%` `n];` `            ``# Pop the top element``            ``# of the stack``            ``s.pop();` `        ``s.append(i ``%` `n);``        ``i ``+``=` `1``;` `    ``# Print the nge[] array``    ``for` `i ``in` `range``(n) :``        ``print``(nge[i], end``=` `" "``);` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``4``, ``-``2``, ``5``, ``8` `];``    ``N ``=` `len``(arr);` `    ``# Function Call``    ``printNGE(arr, N);``    ` `    ``# This code is contributed by AnkitRai01`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `// Function to find the NGE for the``// given circular array []arr``static` `void` `printNGE(``int` `[]arr, ``int` `n)``{``    ` `    ``// Initialize stack and nge[] array``    ``Stack<``int``> s = ``new` `Stack<``int``>();``    ``int` `[]nge = ``new` `int``[n];``    ``int` `i = 0;` `    ``// Initialize nge[] array to -1``    ``for``(i = 0; i < n; i++)``    ``{``        ``nge[i] = -1;``    ``}``    ``i = 0;` `    ``// Traverse the array``    ``while` `(i < 2 * n)``    ``{``        ` `        ``// If stack is not empty and``        ``// current element is greater``        ``// than top element of the stack``        ``while` `(s.Count != 0 &&``               ``arr[i % n] > arr[s.Peek()])``        ``{``            ` `            ``// Assign next greater element``            ``// for the top element of the stack``            ``nge[s.Peek()] = arr[i % n];``            ` `            ``// Pop the top element``            ``// of the stack``            ``s.Pop();``        ``}``        ``s.Push(i % n);``        ``i++;``    ``}``    ` `    ``// Print the nge[] array``    ``for``(i = 0; i < n; i++)``    ``{``        ``Console.Write(nge[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 4, -2, 5, 8 };``    ``int` `N = arr.Length;` `    ``// Function Call``    ``printNGE(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`5 5 8 -1`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up