# Find the nearest smaller numbers on left side in an array

Given an array of integers, find the nearest smaller number for every element such that the smaller element is on left side.

Examples:

```Input:  arr[] = {1, 6, 4, 10, 2, 5}
Output:         {_, 1, 1,  4, 1, 2}
First element ('1') has no element on left side. For 6,
there is only one smaller element on left side '1'.
For 10, there are three smaller elements on left side (1,
6 and 4), nearest among the three elements is 4.

Input: arr[] = {1, 3, 0, 2, 5}
Output:        {_, 1, _, 0, 2}
```

Expected time complexity is O(n).

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

A Simple Solution is to use two nested loops. The outer loop starts from second element, the inner loop goes to all elements on left side of the element picked by outer loop and stops as soon as it finds a smaller element.

## C++

 `// C++ implementation of simple algorithm to find ` `// smaller element on left side ` `#include ` `using` `namespace` `std; ` ` `  `// Prints smaller elements on left side of every element ` `void` `printPrevSmaller(``int` `arr[], ``int` `n) ` `{ ` `    ``// Always print empty or '_' for first element ` `    ``cout << ``"_, "``; ` ` `  `    ``// Start from second element ` `    ``for` `(``int` `i=1; i=0; j--) ` `        ``{ ` `            ``if` `(arr[j] < arr[i]) ` `            ``{ ` `                ``cout << arr[j] << ``", "``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If there is no smaller element on left of 'i' ` `        ``if` `(j == -1) ` `           ``cout << ``"_, "` `; ` `    ``} ` `} ` ` `  `/* Driver program to test insertion sort */` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 3, 0, 2, 5}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `    ``printPrevSmaller(arr, n); ` `    ``return` `0; ` `}`

## Java

 `// Java implementation of simple  ` `// algorithm to find smaller  ` `// element on left side ` `import` `java.io.*; ` `class` `GFG { ` ` `  `// Prints smaller elements on  ` `// left side of every element ` `static` `void` `printPrevSmaller(``int` `[]arr, ``int` `n) ` `{ ` `     `  `    ``// Always print empty or '_' ` `    ``// for first element ` `    ``System.out.print( ``"_, "``); ` ` `  `    ``// Start from second element ` `    ``for` `(``int` `i = ``1``; i < n; i++) ` `    ``{ ` `        ``// look for smaller ` `        ``// element on left of 'i' ` `        ``int` `j; ` `        ``for``(j = i - ``1``; j >= ``0``; j--) ` `        ``{ ` `            ``if` `(arr[j] < arr[i]) ` `            ``{ ` `                ``System.out.print(arr[j] + ``", "``); ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If there is no smaller ` `        ``// element on left of 'i' ` `        ``if` `(j == -``1``) ` `        ``System.out.print( ``"_, "``) ; ` `    ``} ` `} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `[]arr = {``1``, ``3``, ``0``, ``2``, ``5``}; ` `        ``int` `n = arr.length; ` `        ``printPrevSmaller(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## Python3

 `# Python 3 implementation of simple  ` `# algorithm to find smaller element ` `# on left side ` ` `  `# Prints smaller elements on left ` `# side of every element ` `def` `printPrevSmaller(arr, n): ` ` `  `    ``# Always print empty or '_' for ` `    ``# first element ` `    ``print``(``"_, "``, end``=``"") ` ` `  `    ``# Start from second element ` `    ``for` `i ``in` `range``(``1``, n ): ` `     `  `        ``# look for smaller element ` `        ``# on left of 'i' ` `        ``for` `j ``in` `range``(i``-``1` `,``-``2` `,``-``1``): ` `         `  `            ``if` `(arr[j] < arr[i]): ` `             `  `                ``print``(arr[j] ,``", "``,  ` `                            ``end``=``"") ` `                ``break` ` `  `        ``# If there is no smaller  ` `        ``# element on left of 'i' ` `        ``if` `(j ``=``=` `-``1``): ` `            ``print``(``"_, "``, end``=``"") ` ` `  `# Driver program to test insertion ` `# sort ` `arr ``=` `[``1``, ``3``, ``0``, ``2``, ``5``] ` `n ``=` `len``(arr) ` `printPrevSmaller(arr, n) ` ` `  `# This code is contributed by ` `# Smitha `

## C#

 `// C# implementation of simple  ` `// algorithm to find smaller  ` `// element on left side ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Prints smaller elements on  ` `    ``// left side of every element ` `    ``static` `void` `printPrevSmaller(``int` `[]arr, ` `                                    ``int` `n) ` `    ``{ ` `         `  `        ``// Always print empty or '_' ` `        ``// for first element ` `        ``Console.Write( ``"_, "``); ` `     `  `        ``// Start from second element ` `        ``for` `(``int` `i = 1; i < n; i++) ` `        ``{ ` `            ``// look for smaller ` `            ``// element on left of 'i' ` `            ``int` `j; ` `            ``for``(j = i - 1; j >= 0; j--) ` `            ``{ ` `                ``if` `(arr[j] < arr[i]) ` `                ``{ ` `                    ``Console.Write(arr[j] ` `                                ``+ ``", "``); ` `                    ``break``; ` `                ``} ` `            ``} ` `     `  `            ``// If there is no smaller ` `            ``// element on left of 'i' ` `            ``if` `(j == -1) ` `            ``Console.Write( ``"_, "``) ; ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main () ` `    ``{ ` `        ``int` `[]arr = {1, 3, 0, 2, 5}; ` `        ``int` `n = arr.Length; ` `        ``printPrevSmaller(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## PHP

 `= 0; ``\$j``--) ` `        ``{ ` `            ``if` `(``\$arr``[``\$j``] < ``\$arr``[``\$i``]) ` `            ``{ ` `                ``echo` `\$arr``[``\$j``] , ``", "``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If there is no smaller ` `        ``// element on left of 'i' ` `        ``if` `(``\$j` `== -1) ` `        ``echo` `"_, "` `; ` `    ``} ` `} ` ` `  `    ``// Driver Code ` `    ``\$arr` `= ``array``(1, 3, 0, 2, 5); ` `    ``\$n` `= ``count``(``\$arr``); ` `    ``printPrevSmaller(``\$arr``, ``\$n``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output:

`_, 1, _, 0, 2, ,`

Time complexity of the above solution is O(n2).

There can be an Efficient Solution that works in O(n) time. The idea is to use a stack. Stack is used to maintain a subsequence of the values that have been processed so far and are smaller than any later value that has already been processed.

Below is stack based algorithm

```Let input sequence be 'arr[]' and size of array be 'n'

1) Create a new empty stack S

2) For every element 'arr[i]' in the input sequence 'arr[]',
where 'i' goes from 0 to n-1.
a) while S is nonempty and the top element of
S is greater than or equal to 'arr[i]':
pop S

b) if S is empty:
'arr[i]' has no preceding smaller value
c) else:
the nearest smaller value to 'arr[i]' is
the top element of S

d) push 'arr[i]' onto S```

Below is the implementation of above algorithm.

## C++

 `// C++ implementation of efficient algorithm to find ` `// smaller element on left side ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Prints smaller elements on left side of every element ` `void` `printPrevSmaller(``int` `arr[], ``int` `n) ` `{ ` `    ``// Create an empty stack ` `    ``stack<``int``> S; ` ` `  `    ``// Traverse all array elements ` `    ``for` `(``int` `i=0; i= arr[i]) ` `            ``S.pop(); ` ` `  `        ``// If all elements in S were greater than arr[i] ` `        ``if` `(S.empty()) ` `            ``cout << ``"_, "``; ` `        ``else`  `//Else print the nearest smaller element ` `            ``cout << S.top() << ``", "``; ` ` `  `        ``// Push this element ` `        ``S.push(arr[i]); ` `    ``} ` `} ` ` `  `/* Driver program to test insertion sort */` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 3, 0, 2, 5}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `    ``printPrevSmaller(arr, n); ` `    ``return` `0; ` `} `

## Java

 `import` `java.util.Stack; ` ` `  `//Java implementation of efficient algorithm to find  ` `// smaller element on left side  ` `class` `GFG { ` ` `  `// Prints smaller elements on left side of every element  ` `    ``static` `void` `printPrevSmaller(``int` `arr[], ``int` `n) { ` `        ``// Create an empty stack  ` `        ``Stack S = ``new` `Stack<>(); ` ` `  `        ``// Traverse all array elements  ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``// Keep removing top element from S while the top  ` `            ``// element is greater than or equal to arr[i]  ` `            ``while` `(!S.empty() && S.peek() >= arr[i]) { ` `                ``S.pop(); ` `            ``} ` ` `  `            ``// If all elements in S were greater than arr[i]  ` `            ``if` `(S.empty()) { ` `                ``System.out.print(``"_, "``); ` `            ``} ``else` `//Else print the nearest smaller element  ` `            ``{ ` `                ``System.out.print(S.peek() + ``", "``); ` `            ``} ` ` `  `            ``// Push this element  ` `            ``S.push(arr[i]); ` `        ``} ` `    ``} ` ` `  `    ``/* Driver program to test insertion sort */` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `arr[] = {``1``, ``3``, ``0``, ``2``, ``5``}; ` `        ``int` `n = arr.length; ` `        ``printPrevSmaller(arr, n); ` `    ``} ` `} `

## Python3

 `# Python3 implementation of efficient  ` `# algorithm to find smaller element ` `# on left side ` `import` `math as mt ` ` `  `# Prints smaller elements on left  ` `# side of every element ` `def` `printPrevSmaller(arr, n): ` ` `  `    ``# Create an empty stack ` `    ``S ``=` `list``() ` ` `  `    ``# Traverse all array elements ` `    ``for` `i ``in` `range``(n): ` `     `  `        ``# Keep removing top element from S  ` `        ``# while the top element is greater  ` `        ``# than or equal to arr[i] ` `        ``while` `(``len``(S) > ``0` `and` `S[``-``1``] >``=` `arr[i]): ` `            ``S.pop() ` ` `  `        ``# If all elements in S were greater ` `        ``# than arr[i] ` `        ``if` `(``len``(S) ``=``=` `0``): ` `            ``print``(``"_, "``, end ``=` `"") ` `        ``else``: ``# Else print the nearest  ` `              ``# smaller element ` `            ``print``(S[``-``1``], end ``=` `", "``) ` ` `  `        ``# Push this element ` `        ``S.append(arr[i]) ` `     `  `# Driver Code ` `arr ``=` `[ ``1``, ``3``, ``0``, ``2``, ``5``] ` `n ``=` `len``(arr) ` `printPrevSmaller(arr, n) ` ` `  `# This code is contributed by ` `# Mohit kumar 29 `

## C#

 `// C# implementation of efficient algorithm to find  ` `// smaller element on left side ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `public` `class` `GFG ` `{ ` ` `  `    ``// Prints smaller elements on left side of every element  ` `    ``static` `void` `printPrevSmaller(``int` `[]arr, ``int` `n)  ` `    ``{ ` `        ``// Create an empty stack  ` `        ``Stack<``int``> S = ``new` `Stack<``int``>(); ` ` `  `        ``// Traverse all array elements  ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``// Keep removing top element from S while the top  ` `            ``// element is greater than or equal to arr[i]  ` `            ``while` `(S.Count != 0 && S.Peek() >= arr[i]) ` `            ``{ ` `                ``S.Pop(); ` `            ``} ` ` `  `            ``// If all elements in S were greater than arr[i]  ` `            ``if` `(S.Count == 0) ` `            ``{ ` `                ``Console.Write(``"_, "``); ` `            ``}  ` `            ``else` `//Else print the nearest smaller element  ` `            ``{ ` `                ``Console.Write(S.Peek() + ``", "``); ` `            ``} ` ` `  `            ``// Push this element  ` `            ``S.Push(arr[i]); ` `        ``} ` `    ``} ` ` `  `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[]arr = {1, 3, 0, 2, 5}; ` `        ``int` `n = arr.Length; ` `        ``printPrevSmaller(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

`_, 1, _, 0, 2,`

Time complexity of above program is O(n) as every element is pushed and popped at most once to the stack. So overall constant number of operations are performed per element.