Closest greater or same value on left side for every element in array

Given an array of integers, our goal is to find, for each element, the closest value on its left side that is greater than or equal to the element itself. In essence, we need to construct a new array where each element corresponds to the closest greater or equal value on the left side of the original array.

For example, consider the array: [5, 9, 3, 6, 8]. The new array, following the problem's criteria, would be: [-1, -1, 5, 9, 9]. In this case, for the first element '5', there is no element greater than or equal to it on its left side, so it remains '-1'. The second element '9' has no greater or equal value on its left side, making it '-1'. The third element '3' has the closest greater or equal value '5' on its left side. Similarly, the fourth and fifth elements '6' and '8' have their respective closest greater or equal values on the left.

Note: Before looking into the solution, I would highly recommend you to think of an approach

Brute Force Approach

One straightforward approach to solving this problem is to use a brute force algorithm. For each element in the array, we can iterate through its left side and find the closest greater or equal value. This approach involves nested loops and has a time complexity of O(n^2), where 'n' is the number of elements in the array. While this approach is conceptually simple, it's not suitable for larger arrays due to its inefficiency.

class Main {

    // Function to find the closest greater or equal value on the left side for each element
    public static int[] findClosestGreaterOrEqual(int[] array) {
        int n = array.length;  // Length of the input array
        int[] result = new int[n];  // Array to store the results
    
        // Loop through each element in the array
        for (int i = 0; i < n; i++) {
            int closestValue = -1;  // Initialize the closest value to -1
            
            // Loop through elements on the left side of the current element
            for (int j = i - 1; j >= 0; j--) {
                // Check if the current left-side element is greater than or equal to the current element
                if (array[j] >= array[i]) {
                    closestValue = array[j];  // Update the closest value
                    break;  // Break the loop as we found the required value
                }
            }
            
            result[i] = closestValue;  // Store the closest value for the current element
        }
    
        return result;  // Return the array containing closest values for each element
    }
    
    public static void main(String[] args) {
        int[] array = {5, 9, 3, 6, 8};  // Input array
        
        // Using the findClosestGreaterOrEqual function to get the result
        int[] result = findClosestGreaterOrEqual(array);
        
        // Print the result
        System.out.print("Resulting array: ");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }
}

Output:

Closest greater or same value on left side for every element in array

In this approach, for each element at index 'i', we iterate through elements from 'i-1' to '0' and find the closest greater or equal value. This approach has a time complexity of O(n^2), where 'n' is the number of elements in the array.

Optimized Approach using Stack

To improve the efficiency of our solution, we can utilize a stack-based approach. The idea is to maintain a stack that holds the indices of elements in decreasing order of their values as we traverse the array from left to right. This ensures that the elements in the stack are always greater than or equal to the current element.

As we encounter each new element, we can pop elements from the stack until we find a value that's greater than or equal to the current element or until the stack becomes empty. The index of the element at the top of the stack (if any) gives us the closest greater or equal value on the left side for the current element.

This approach has a time complexity of O(n) since each element is pushed and popped from the stack only once. The stack size never exceeds the number of elements, and each element is processed exactly once.

import java.util.*;

class Main {

    // Function to find the closest greater or equal value on the left side for each element
    public static int[] findClosestGreaterOrEqual(int[] array) {
        int n = array.length; // Get the length of the input array
        int[] result = new int[n]; // Array to store the closest values
        Stack<Integer> stack = new Stack<>(); // Create a stack to keep track of indices
    
        for (int i = 0; i < n; i++) { // Loop through each element in the array
            while (!stack.isEmpty() && array[stack.peek()] < array[i]) {
                // While the stack is not empty and the value at the current top of the stack
                // is less than the value of the current element
                stack.pop(); // Pop elements from the stack (remove smaller elements)
            }
    
            // After the while loop, the stack contains only indices of elements
            // with values greater than or equal to the current element
    
            // If the stack is empty, there is no element on the left side that is greater or equal,
            // so assign -1 as the closest value
            // Otherwise, assign the value of the element at the index from the top of the stack
            result[i] = stack.isEmpty() ? -1 : array[stack.peek()];
    
            stack.push(i); // Push the current index onto the stack
        }
    
        return result; // Return the array containing closest values for each element
    }

    public static void main(String[] args) {
        int[] array = {5, 9, 3, 6, 8}; // Input array
        
        // Using the findClosestGreaterOrEqual function to get the result
        int[] result = findClosestGreaterOrEqual(array);
        
        // Print the result
        System.out.print("Resulting array: ");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }
}

Output: