Previous greater element

• Difficulty Level : Medium
• Last Updated : 13 May, 2021

Given an array of distinct elements, find previous greater element for every element. If previous greater element does not exist, print -1.
Examples:

```Input : arr[] = {10, 4, 2, 20, 40, 12, 30}
Output :         -1, 10, 4, -1, -1, 40, 40

Input : arr[] = {10, 20, 30, 40}
Output :        -1, -1, -1, -1

Input : arr[] = {40, 30, 20, 10}
Output :        -1, 40, 30, 20```

Expected time complexity : O(n)

A simple solution is to run two nested loops. The outer loop picks an element one by one. The inner loop, find the previous element that is greater.

C++

 `// C++ program previous greater element``// A naive solution to print previous greater``// element for every element in an array.``#include ``using` `namespace` `std;` `void` `prevGreater(``int` `arr[], ``int` `n)``{``    ``// Previous greater for first element never``    ``// exists, so we print -1.``    ``cout << ``"-1, "``;` `    ``// Let us process remaining elements.``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Find first element on left side``        ``// that is greater than arr[i].``        ``int` `j;``        ``for` `(j = i-1; j >= 0; j--) {``            ``if` `(arr[i] < arr[j]) {``            ``cout << arr[j] << ``", "``;``            ``break``;``            ``}            ``        ``}` `        ``// If all elements on left are smaller.``        ``if` `(j == -1)``        ``cout << ``"-1, "``;``    ``}``}``// Driver code``int` `main()``{``    ``int` `arr[] = { 10, 4, 2, 20, 40, 12, 30 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``prevGreater(arr, n);``    ``return` `0;``}`

Java

 `// Java program previous greater element``// A naive solution to print``// previous greater element``// for every element in an array.``import` `java.io.*;``import` `java.util.*;``import` `java.lang.*;` `class` `GFG``{``static` `void` `prevGreater(``int` `arr[],``                        ``int` `n)``{``    ``// Previous greater for``    ``// first element never``    ``// exists, so we print -1.``    ``System.out.print(``"-1, "``);` `    ``// Let us process``    ``// remaining elements.``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{` `        ``// Find first element on``        ``// left side that is``        ``// greater than arr[i].``        ``int` `j;``        ``for` `(j = i-``1``; j >= ``0``; j--)``        ``{``            ``if` `(arr[i] < arr[j])``            ``{``            ``System.out.print(arr[j] + ``", "``);``            ``break``;``            ``}            ``        ``}` `        ``// If all elements on``        ``// left are smaller.``        ``if` `(j == -``1``)``        ``System.out.print(``"-1, "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = {``10``, ``4``, ``2``, ``20``, ``40``, ``12``, ``30``};``    ``int` `n = arr.length;``    ``prevGreater(arr, n);``}``}`

Python 3

 `# Python 3 program previous greater element``# A naive solution to print previous greater``# element for every element in an array.``def` `prevGreater(arr, n) :` `    ``# Previous greater for first element never``    ``# exists, so we print -1.``    ``print``(``"-1"``,end ``=` `", "``)` `    ``# Let us process remaining elements.``    ``for` `i ``in` `range``(``1``, n) :``        ``flag ``=` `0` `        ``# Find first element on left side``        ``# that is greater than arr[i].``        ``for` `j ``in` `range``(i``-``1``, ``-``1``, ``-``1``) :``            ``if` `arr[i] < arr[j] :``                ``print``(arr[j],end ``=` `", "``)``                ``flag ``=` `1``                ``break` `        ``# If all elements on left are smaller.``        ``if` `j ``=``=` `0` `and` `flag ``=``=` `0``:``            ``print``(``"-1"``,end ``=` `", "``)`  `# Driver code``if` `__name__ ``=``=` `"__main__"` `:``    ``arr ``=` `[``10``, ``4``, ``2``, ``20``, ``40``, ``12``, ``30``]``    ``n ``=` `len``(arr)``    ``prevGreater(arr, n)` `# This code is contributed by ANKITRAI1`

C#

 `// C# program previous greater element``// A naive solution to print``// previous greater element``// for every element in an array.` `using` `System;``class` `GFG``{``static` `void` `prevGreater(``int``[] arr,``                        ``int` `n)``{``    ``// Previous greater for``    ``// first element never``    ``// exists, so we print -1.``    ``Console.Write(``"-1, "``);` `    ``// Let us process``    ``// remaining elements.``    ``for` `(``int` `i = 1; i < n; i++)``    ``{` `        ``// Find first element on``        ``// left side that is``        ``// greater than arr[i].``        ``int` `j;``        ``for` `(j = i-1; j >= 0; j--)``        ``{``            ``if` `(arr[i] < arr[j])``            ``{``            ``Console.Write(arr[j] + ``", "``);``            ``break``;``            ``}            ``        ``}` `        ``// If all elements on``        ``// left are smaller.``        ``if` `(j == -1)``        ``Console.Write(``"-1, "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = {10, 4, 2, 20, 40, 12, 30};``    ``int` `n = arr.Length;``    ``prevGreater(arr, n);``}``}`

PHP

 `= 0; ``\$j``--)``    ``{``            ``if` `(``\$arr``[``\$i``] < ``\$arr``[``\$j``])``        ``{``            ``echo``(``\$arr``[``\$j``]);``        ``echo``( ``", "``);``            ``break``;``            ``}            ``        ``}` `        ``// If all elements on left are smaller.``        ``if` `(``\$j` `== -1)``        ``echo``(``"-1, "``);``    ``}``}` `// Driver code``\$arr` `= ``array``(10, 4, 2, 20, 40, 12, 30);``\$n` `= sizeof(``\$arr``) ;``prevGreater(``\$arr``, ``\$n``);` `//This code is contributed by Shivi_Aggarwal.``    ` `?>`

Javascript

 ``

Output:

`-1, 10, 4, -1, -1, 40, 40`

An efficient solution is to use stack data structure. If we take a closer look, we can notice that this problem is a variation of stock span problem. We maintain previous greater element in a stack.

C++

 `// C++ program previous greater element``// An efficient solution to print previous greater``// element for every element in an array.``#include ``using` `namespace` `std;` `void` `prevGreater(``int` `arr[], ``int` `n)``{``    ``// Create a stack and push index of first element``    ``// to it``    ``stack<``int``> s;``    ``s.push(arr[0]);``    ` `    ``// Previous greater for first element is always -1.``    ``cout << ``"-1, "``;` `    ``// Traverse remaining elements``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Pop elements from stack while stack is not empty``        ``// and top of stack is smaller than arr[i]. We``        ``// always have elements in decreasing order in a``        ``// stack.``        ``while` `(s.empty() == ``false` `&& s.top() < arr[i])``            ``s.pop();` `        ``// If stack becomes empty, then no element is greater``        ``// on left side. Else top of stack is previous``        ``// greater.``        ``s.empty() ? cout << ``"-1, "` `: cout << s.top() << ``", "``;` `        ``s.push(arr[i]);``    ``}``}``// Driver code``int` `main()``{``    ``int` `arr[] = { 10, 4, 2, 20, 40, 12, 30 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``prevGreater(arr, n);``    ``return` `0;``}`

Java

 `// Java program previous greater element``// An efficient solution to``// print previous greater``// element for every element``// in an array.``import` `java.io.*;``import` `java.util.*;``import` `java.lang.*;` `class` `GFG``{``static` `void` `prevGreater(``int` `arr[],``                        ``int` `n)``{``    ``// Create a stack and push``    ``// index of first element``    ``// to it``    ``Stack s = ``new` `Stack();``    ``s.push(arr[``0``]);``    ` `    ``// Previous greater for``    ``// first element is always -1.``    ``System.out.print(``"-1, "``);` `    ``// Traverse remaining elements``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{` `        ``// Pop elements from stack``        ``// while stack is not empty``        ``// and top of stack is smaller``        ``// than arr[i]. We always have``        ``// elements in decreasing order``        ``// in a stack.``        ``while` `(s.empty() == ``false` `&&``            ``s.peek() < arr[i])``            ``s.pop();` `        ``// If stack becomes empty, then``        ``// no element is greater on left``        ``// side. Else top of stack is``        ``// previous greater.``        ``if` `(s.empty() == ``true``)``            ``System.out.print(``"-1, "``);``        ``else``            ``System.out.print(s.peek() + ``", "``);` `        ``s.push(arr[i]);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``10``, ``4``, ``2``, ``20``, ``40``, ``12``, ``30` `};``    ``int` `n = arr.length;``    ``prevGreater(arr, n);``}``}`

Python3

 `# Python3 program to print previous greater element``# An efficient solution to print previous greater``# element for every element in an array.``import` `math as mt` `def` `prevGreater(arr, n):` `    ``# Create a stack and push index of``    ``# first element to it``    ``s ``=` `list``();``    ``s.append(arr[``0``])``    ` `    ``# Previous greater for first element``    ``# is always -1.``    ``print``(``"-1, "``, end ``=` `"")` `    ``# Traverse remaining elements``    ``for` `i ``in` `range``(``1``, n):` `        ``# Pop elements from stack while stack is``        ``# not empty and top of stack is smaller``        ``# than arr[i]. We always have elements in``        ``# decreasing order in a stack.``        ``while` `(``len``(s) > ``0` `and` `s[``-``1``] < arr[i]):``            ``s.pop()` `        ``# If stack becomes empty, then no element``        ``# is greater on left side. Else top of stack``        ``# is previous greater.``        ``if` `len``(s) ``=``=` `0``:``            ``print``(``"-1, "``, end ``=` `"")``        ``else``:``            ``print``(s[``-``1``], ``", "``, end ``=` `"")` `        ``s.append(arr[i])``    ` `# Driver code``arr ``=` `[ ``10``, ``4``, ``2``, ``20``, ``40``, ``12``, ``30` `]``n ``=` `len``(arr)``prevGreater(arr, n)` `# This code is contributed by``# mohit kumar 29`

C#

 `// C# program previous greater element``// An efficient solution to``// print previous greater``// element for every element``// in an array.``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `void` `prevGreater(``int` `[]arr,``                        ``int` `n)``{``    ``// Create a stack and push``    ``// index of first element``    ``// to it``    ``Stack<``int``> s = ``new` `Stack<``int``>();``    ``s.Push(arr[0]);``    ` `    ``// Previous greater for``    ``// first element is always -1.``    ``Console.Write(``"-1, "``);` `    ``// Traverse remaining elements``    ``for` `(``int` `i = 1; i < n; i++)``    ``{` `        ``// Pop elements from stack``        ``// while stack is not empty``        ``// and top of stack is smaller``        ``// than arr[i]. We always have``        ``// elements in decreasing order``        ``// in a stack.``        ``while` `(s.Count != 0 &&``            ``s.Peek() < arr[i])``            ``s.Pop();` `        ``// If stack becomes empty, then``        ``// no element is greater on left``        ``// side. Else top of stack is``        ``// previous greater.``        ``if` `(s.Count == 0)``            ``Console.Write(``"-1, "``);``        ``else``            ``Console.Write(s.Peek() + ``", "``);` `        ``s.Push(arr[i]);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 10, 4, 2, 20, 40, 12, 30 };``    ``int` `n = arr.Length;``    ``prevGreater(arr, n);``}``}` `// This code is contributed by PrinciRaj1992`

Javascript

 ``

Output:

`-1, 10, 4, -1, -1, 40, 40`

Time Complexity: O(n). It seems more than O(n) at first look. If we take a closer look, we can observe that every element of array is added and removed from stack at most once. So there are total 2n operations at most. Assuming that a stack operation takes O(1) time, we can say that the time complexity is O(n).
Auxiliary Space: O(n) in worst case when all elements are sorted in decreasing order.

My Personal Notes arrow_drop_up