Related Articles
Previous greater element
• Difficulty Level : Medium
• Last Updated : 03 Jan, 2020

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)

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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);``    ``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.``     ` `?>`
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);``     ` `    ``// 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);``    ``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); ``     ` `    ``// 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`
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