Find the nearest smaller numbers on left side in an array

31 May, 2022
Given an array of integers, find the nearest smaller number for every element such that the smaller element is on the 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). 
A Simple Solution is to use two nested loops. The outer loop starts from the second element, the inner loop goes to all elements on the left side of the element picked by the outer loop and stops as soon as it finds a smaller element.  
C++
C
Java
Python3
C#
PHP
Javascript
// C++ implementation of simple algorithm to find// smaller element on left side#include <iostream>using namespace std; // Prints smaller elements on left side of every elementvoid printPrevSmaller(int arr[], int n){    // Always print empty or '_' for first element    cout << "_, ";     // 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]) {                cout << arr[j] << ", ";                break;            }        }         // If there is no smaller element on left of 'i'        if (j == -1)            cout << "_, ";    }} int main(){    int arr[] = { 1, 3, 0, 2, 5 };    int n = sizeof(arr) / sizeof(arr[0]);    printPrevSmaller(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C implementation of simple algorithm to find// smaller element on left side#include <stdio.h> // Prints smaller elements on left side of every elementvoid printPrevSmaller(int arr[], int n){    // Always print empty or '_' for first element    printf("_, ");     // 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]) {                printf("%d, ",arr[j]);                break;            }        }         // If there is no smaller element on left of 'i'        if (j == -1)            printf("_, ");    }} /* Driver program to test insertion sort */int main(){    int arr[] = { 1, 3, 0, 2, 5 };    int n = sizeof(arr) / sizeof(arr[0]);    printPrevSmaller(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java implementation of simple algorithm to find smaller// element on left sideimport 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 Aditya Kumar (adityakumar129)
# Python 3 implementation of simple# algorithm to find smaller element# on left side # Prints smaller elements on left# side of every elementdef 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# sortarr = [1, 3, 0, 2, 5]n = len(arr)printPrevSmaller(arr, n) # This code is contributed by# Smitha
// C# implementation of simple// algorithm to find smaller// element on left sideusing 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// PHP implementation of simple// algorithm to find smaller// element on left side // Prints smaller elements on// left side of every elementfunction printPrevSmaller( $arr, $n){         // Always print empty or    // '_' for first element    echo "_, ";     // Start from second element    for($i = 1; $i < $n; $i++)    {                 // look for smaller        // element on left of 'i'        $j;        for($j = $i - 1; $j >= 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.?>
<script>  // Javascript implementation// of simple algorithm to find// smaller element on left side  // Prints smaller elements on// left side of every elementfunction printPrevSmaller( arr, n){    // Always print empty or '_' for first element    document.write("_, ");     // Start from second element    for (let i=1; i<n; i++)    {        // look for smaller element on left of 'i'        let j;        for (j=i-1; j>=0; j--)        {            if (arr[j] < arr[i])            {                 document.write(arr[j] + ", ");                break;            }        }         // If there is no smaller element on left of 'i'        if (j == -1)           document.write("_, ");    }}     // Driver program         let arr = [ 1, 3, 0, 2, 5 ];    let n = arr.length;    printPrevSmaller(arr, n);     </script>
Output: 
_, 1, _, 0, 2, ,
The 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.
Algorithm: Stack-based   
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 the above algorithm. 
C++
Java
Python3
C#
Javascript
// C++ implementation of efficient algorithm to find// smaller element on left side#include <iostream>#include <stack>using namespace std; // Prints smaller elements on left side of every elementvoid printPrevSmaller(int arr[], int n){    // Create an empty stack    stack<int> S;     // 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.top() >= 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]);    }} int main(){    int arr[] = {1, 3, 0, 2, 5};    int n = sizeof(arr)/sizeof(arr[0]);    printPrevSmaller(arr, n);    return 0;}
import java.util.Stack; //Java implementation of efficient algorithm to find// smaller element on left sideclass GFG { // Prints smaller elements on left side of every element    static void printPrevSmaller(int arr[], int n) {        // Create an empty stack        Stack<Integer> 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 implementation of efficient# algorithm to find smaller element# on left sideimport math as mt # Prints smaller elements on left# side of every elementdef 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 Codearr = [ 1, 3, 0, 2, 5]n = len(arr)printPrevSmaller(arr, n) # This code is contributed by# Mohit kumar 29
// C# implementation of efficient algorithm to find// smaller element on left sideusing 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
<script> // Javascript implementation of efficient// algorithm to find smaller element on left side // Prints smaller elements on left// side of every elementfunction printPrevSmaller(arr, n){         // Create an empty stack    let S = [];     // Traverse all array elements    for(let 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.length != 0) &&             (S[S.length - 1] >= arr[i]))        {            S.pop();        }         // If all elements in S were        // greater than arr[i]        if (S.length == 0)        {            document.write("_, ");        }                 // Else print the nearest smaller element        else        {            document.write(S[S.length - 1] + ", ");        }         // Push this element        S.push(arr[i]);    }} // Driver codelet arr = [ 1, 3, 0, 2, 5 ];let n = arr.length; printPrevSmaller(arr, n); // This code is contributed by divyeshrabadiya07 </script>
Output: 
_, 1, _, 0, 2,
Time complexity of the 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.
This article is contributed by Ashish Kumar Singh. Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem. 
vt_m
Smitha Dinesh Semwal
princiraj1992
mohit kumar 29
princi singh
jana_sayantan
divyeshrabadiya07
adityakumar129
rishuabhishek06
Amazon
Arrays
Searching
Stack
Amazon
Arrays
Searching
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.