Next Smaller Element

Given an array, print the Next Smaller Element (NSE) for every element. The NSE for an element x is the first smaller element on the right side of x in the array. For elements for which no smaller element exists (on the right side), then consider NSE as -1. 

Examples:

Input: [4, 8, 5, 2, 25]
Output: [2, 5, 2, -1, -1]
Explanation:
The first element smaller than 4 having index > 0 is 2.
The first element smaller than 8 having index > 1 is 5.
The first element smaller than 5 having index > 2 is 2.
There are no elements smaller than 4 having index > 3.
There are no elements smaller than 4 having index > 4.

Input: [13, 7, 6, 12]
Output: [7, 6, -1, -1]
Explanation:
The first element smaller than 13 having index > 0 is 7.
The first element smaller than 7 having index > 1 is 6.
There are no elements smaller than 6 having index > 2.
There are no elements smaller than 12 having index > 3.

[Naive Approach] Using Nested loops - O(n^2) Time O(1) Space

The outer loop picks all the elements one by one. The inner loop looks for the first smaller element for the element picked by outer loop. If a smaller element is found then that element is printed as next, otherwise, -1 is printed.

Below is the implementation:

// Simple C++ program to print 
// next smaller elements in a given array
#include "bits/stdc++.h"
using namespace std;

/* prints element and NSE pair 
for all elements of arr[] of size n */
void printNSE(int arr[], int n)
{
    int next, i, j;
    for (i = 0; i < n; i++)
    {
        next = -1;
        for (j = i + 1; j < n; j++)
        {
            if (arr[i] > arr[j])
            {
                next = arr[j];
                break;
            }
        }
        cout << arr[i] << " --> " 
             << next << endl;
    }
}

// Driver Code
int main()
{
    int arr[]= {11, 13, 21, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    printNSE(arr, n);
    return 0;
}

     
// Simple C program to print next smaller elements
// in a given array
#include<stdio.h>

/* prints element and NSE pair for all elements of
arr[] of size n */
void printNSE(int arr[], int n)
{
    int next, i, j;
    for (i=0; i<n; i++)
    {
        next = -1;
        for (j = i+1; j<n; j++)
        {
            if (arr[i] > arr[j])
            {
                next = arr[j];
                break;
            }
        }
        printf("%d -- %d\n", arr[i], next);
    }
}

int main()
{
    int arr[]= {11, 13, 21, 3};
    int n = sizeof(arr)/sizeof(arr[0]);
    printNSE(arr, n);
    return 0;
}

// Simple Java program to print next
// smaller elements in a given array

class Main {
    /* prints element and NSE pair for 
     all elements of arr[] of size n */
    static void printNSE(int arr[], int n)
    {
        int next, i, j;
        for (i = 0; i < n; i++) {
            next = -1;
            for (j = i + 1; j < n; j++) {
                if (arr[i] > arr[j]) {
                    next = arr[j];
                    break;
                }
            }
            System.out.println(arr[i] + " -- " + next);
        }
    }

    public static void main(String args[])
    {
        int arr[] = { 11, 13, 21, 3 };
        int n = arr.length;
        printNSE(arr, n);
    }
}

 
# Function to print element and NSE pair for all elements of list
def printNSE(arr):

    for i in range(0, len(arr), 1):

        next = -1
        for j in range(i + 1, len(arr), 1):
            if arr[i] > arr[j]:
                next = arr[j]
                break
            
        print(str(arr[i]) + " -- " + str(next))

# Driver program to test above function
arr = [11, 13, 21, 3]
printNSE(arr)

# This code is contributed by Sunny Karira

// Simple C# program to print next
// smaller elements in a given array
using System;

class GFG {

    /* prints element and NSE pair for 
    all elements of arr[] of size n */
    static void printNSE(int[] arr, int n)
    {
        int next, i, j;
        for (i = 0; i < n; i++) {
            next = -1;
            for (j = i + 1; j < n; j++) {
                if (arr[i] > arr[j]) {
                    next = arr[j];
                    break;
                }
            }
            Console.WriteLine(arr[i] + " -- " + next);
        }
    }

    // driver code
    public static void Main()
    {
        int[] arr = { 11, 13, 21, 3 };
        int n = arr.Length;

        printNSE(arr, n);
    }
}

// This code is contributed by Sam007

// Simple Javascript program to print 
// next smaller elements in a given array

/* prints element and NSE pair 
for all elements of arr[] of size n */
function printNSE(arr, n)
{
    var next, i, j;
    for (i = 0; i < n; i++)
    {
        next = -1;
        for (j = i + 1; j < n; j++)
        {
            if (arr[i] > arr[j])
            {
                next = arr[j];
                break;
            }
        }
        console.log( arr[i] + " --> " 
             + next );
    }
}

// Driver Code
var arr= [11, 13, 21, 3];   
var n = arr.length;
printNSE(arr, n);

11 --> 3
13 --> 3
21 --> 3
3 --> -1

Time Complexity: O(N^2) where N is the size of the input array.
Auxiliary Space: O(1)

[Expected Approach] using Stack - O(n) Time O(n) Space

The idea is to find the next smaller element for each element in the list using a monotonic stack. We traverse the list while maintaining a stack that keeps indices of elements in decreasing order. If the current element is smaller than the element at the stack's top, it becomes the next smaller element for that index. We then update the result and pop the stack until this condition no longer holds. If no smaller element exists, we keep -1.

Steps to implement the above idea:

• Initialize a list next_smaller with -1 and an empty stack.
• Iterate through the list while maintaining a monotonic decreasing stack (stores indices).
• Check if the current element is smaller than the element at the stack's top.
• Update next_smaller for popped indices and remove elements from the stack.
• Push the current index onto the stack to maintain order.
• Return the next_smaller list after completing the traversal.

Below is the implementation of the above approach:

#include <bits/stdc++.h>
using namespace std;

// Function to find the next smaller element for each element in the array
vector<int> findNextSmallerElement(const vector<int>& arr) {
    int n = arr.size();

    // Stores the next smaller elements, initialized with -1
    vector<int> nextSmaller(n, -1);

    // Monotonic stack to keep track of indices
    stack<int> stk;

    // Iterate through the array
    for (int i = 0; i < n; i++) {
        // Maintain a increasing order in the stack
        while (!stk.empty() && arr[i] < arr[stk.top()]) {
            nextSmaller[stk.top()] = arr[i]; // Assign the next smaller element
            stk.pop(); // Remove processed element
        }

        // Push the current index onto the stack
        stk.push(i);
    }

    return nextSmaller;
}

// Driver function
int main() {
    // Input array
    vector<int> arr = {4, 8, 2, 1, 6, 10, 5};

    // Function call to find next smaller elements
    vector<int> result = findNextSmallerElement(arr);

    // Print the original array
    cout << "Original Array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;

    // Print the next smaller elements
    cout << "Next Smaller Elements: ";
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

import java.util.*;

class GfG {
    // Function to find the next smaller element for each element in the array
    static List<Integer> findNextSmallerElement(List<Integer> arr) {
        int n = arr.size();

        // Stores the next smaller elements, initialized with -1
        List<Integer> nextSmaller = new ArrayList<>(Collections.nCopies(n, -1));

        // Monotonic stack to keep track of indices
        Stack<Integer> stk = new Stack<>();

        // Iterate through the array
        for (int i = 0; i < n; i++) {
            
            // Maintain a increasing order in the stack
            while (!stk.isEmpty() && arr.get(i) < arr.get(stk.peek())) {
                nextSmaller.set(stk.pop(), arr.get(i)); // Assign the next smaller element
            }

            // Push the current index onto the stack
            stk.push(i);
        }

        return nextSmaller;
    }

    // Driver function
    public static void main(String[] args) {
        // Input list
        List<Integer> arr = Arrays.asList(4, 8, 2, 1, 6, 10, 5);

        // Function call to find next smaller elements
        List<Integer> result = findNextSmallerElement(arr);

        // Print the original list
        System.out.println("Original List: " + arr);

        // Print the next smaller elements
        System.out.println("Next Smaller Elements: " + result);
    }
}

def find_next_smaller_element(arr):
    n = len(arr)

    # Stores the next smaller elements, initialized with -1
    next_smaller = [-1] * n

    # Monotonic stack to keep track of indices
    stk = []

    # Iterate through the array
    for i in range(n):
        # Maintain a increasing order in the stack
        while stk and arr[i] < arr[stk[-1]]:
            next_smaller[stk.pop()] = arr[i]  # Assign the next smaller element

        # Push the current index onto the stack
        stk.append(i)

    return next_smaller


if __name__ == "__main__":
    # Input list
    arr = [4, 8, 2, 1, 6, 10, 5]

    # Function call to find next smaller elements
    result = find_next_smaller_element(arr)

    # Print the original list
    print("Original List:", arr)

    # Print the next smaller elements
    print("Next Smaller Elements:", result)

using System;
using System.Collections.Generic;

class GfG {
    // Function to find the next smaller element for each element in the list
    public static List<int> FindNextSmallerElement(List<int> arr) {
        int n = arr.Count;

        // Stores the next smaller elements, initialized with -1
        List<int> nextSmaller = new List<int>(new int[n]);
        for (int i = 0; i < n; i++) {
            nextSmaller[i] = -1;
        }

        // Monotonic stack to keep track of indices
        Stack<int> stk = new Stack<int>();

        // Iterate through the list
        for (int i = 0; i < n; i++) {
            // Maintain a increasing order in the stack
            while (stk.Count > 0 && arr[i] < arr[stk.Peek()]) {
                nextSmaller[stk.Pop()] = arr[i]; // Assign the next smaller element
            }

            // Push the current index onto the stack
            stk.Push(i);
        }

        return nextSmaller;
    }

    // Driver function
    public static void Main() {
        // Input list
        List<int> arr = new List<int> { 4, 8, 2, 1, 6, 10, 5 };

        // Function call to find next smaller elements
        List<int> result = FindNextSmallerElement(arr);

        // Print the original list
        Console.WriteLine("Original List: " + string.Join(" ", arr));

        // Print the next smaller elements
        Console.WriteLine("Next Smaller Elements: " + string.Join(" ", result));
    }
}

function findNextSmallerElement(arr) {
    let n = arr.length;

    // Stores the next smaller elements, initialized with -1
    let nextSmaller = new Array(n).fill(-1);

    // Monotonic stack to keep track of indices
    let stk = [];

    // Iterate through the array
    for (let i = 0; i < n; i++) {
        // Maintain a increasing order in the stack
        while (stk.length > 0 && arr[i] < arr[stk[stk.length - 1]]) {
            nextSmaller[stk.pop()] = arr[i]; // Assign the next smaller element
        }

        // Push the current index onto the stack
        stk.push(i);
    }

    return nextSmaller;
}

// Input array
let arr = [4, 8, 2, 1, 6, 10, 5];

// Function call to find next smaller elements
let result = findNextSmallerElement(arr);

// Print the original list
console.log("Original List:", arr.join(" "));

// Print the next smaller elements
console.log("Next Smaller Elements:", result.join(" "));

Original Array: 4 8 2 1 6 10 5 
Next Smaller Elements: 2 2 1 -1 5 5 -1 

Time Complexity: O(n) since each element is pushed and popped from the stack at most once.
Auxiliary Space: O(n) due to the result list and stack storing indices.