First strictly smaller element in a sorted array in Java

Given a sorted array and a target value, find the first element that is strictly smaller than given element.

Examples:

Input : arr[] = {1, 2, 3, 5, 8, 12} 
        Target = 5
Output : 2 (Index of 3)

Input : {1, 2, 3, 5, 8, 12} 
        Target = 8
Output : 3 (Index of 5)

Input : {1, 2, 3, 5, 8, 12} 
        Target = 15
Output : -1

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

A simple solution is to linearly traverse given array and find first element that is strictly greater. If no such element exists, then return -1.

An efficient solution is to use Binary Search. In a general binary search, we are looking for a value which appears in the array. Sometimes, however, we need to find the first element which is either greater than a target.

To see that this algorithm is correct, consider each comparison being made. If we find an element that’s greater than the target element, then it and everything above it can’t possibly match, so there’s no need to search that region. We can thus search the left half. If we find an element that is smaller than the element in question, then anything before it must also be larger, so they can’t be the first element that’s smaller and so we don’t need to search them. The middle element is thus the last possible place it could be.

Note that on each iteration we drop off at least half the remaining elements from consideration. If the top branch executes, then the elements in the range [low, (low + high) / 2] are all discarded, causing us to lose floor((low + high) / 2) – low + 1 >= (low + high) / 2 – low = (high – low) / 2 elements.

If the bottom branch executes, then the elements in the range [(low + high) / 2 + 1, high] are all discarded. This loses us high – floor(low + high) / 2 + 1 >= high – (low + high) / 2 = (high – low) / 2 elements.

Consequently, we’ll end up finding the first element smaller than the target in O(lg n) iterations of this process.

C++

// C++ program to find first element that  
// is strictly greater than given target.  
#include<bits/stdc++.h> 
using namespace std; 
  
int next(int arr[], int target, int end)  
{  
    int start = 0;  
  
    int ans = -1;  
    while (start <= end)  
    {  
        int mid = (start + end) / 2;  
  
        // Move to the left side if the target is smaller  
        if (arr[mid] >= target)  
        {  
            end = mid - 1;  
        }  
  
        // Move right side  
        else 
        {  
            ans = mid;  
            start = mid + 1;  
        }  
    }  
    return ans;  
}  
  
// Driver code  
int main()  
{  
    int arr[] = { 1, 2, 3, 5, 8, 12 };  
    int n = sizeof(arr)/sizeof(arr[0]); 
    cout << (next(arr, 5, n));  
    return 0; 
}  
  
// This code is contributed by Rajput-Ji 

Java

// Java program to find first element that  
// is strictly greater than given target.  
    
class GfG {  
    
    private static int next(int[] arr, int target)  
    {  
        int start = 0, end = arr.length-1;  
    
        int ans = -1;  
        while (start <= end) {  
            int mid = (start + end) / 2;  
    
            // Move to the left side if the target is smaller  
            if (arr[mid] >= target) {  
                end = mid - 1;  
            }  
    
            // Move right side  
            else {  
                ans = mid;  
                start = mid + 1;  
            }  
        }  
        return ans;  
    }  
    
    // Driver code  
    public static void main(String[] args)  
    {  
        int[] arr = { 1, 2, 3, 5, 8, 12 };  
        System.out.println(next(arr, 5));  
    }  
}  

Python3

# Python3 program to find first element that  
# is strictly smaller than given target 
    
def next(arr, target):  
  
    start = 0;  
    end = len(arr) - 1;  
    
    ans = -1;  
    while (start <= end):  
        mid = (start + end) // 2;  
    
        # Move to the left side if target is  
        # smaller  
        if (arr[mid] >= target):  
            end = mid - 1;  
    
        # Move right side  
        else:  
            ans = mid;  
            start = mid + 1;  
    
    return ans;  
    
# Driver code  
if __name__ == '__main__':  
  
    arr = [ 1, 2, 3, 5, 8, 12 ];  
    print(next(arr, 5));  
    
# This code is contributed by Yash_R  

C#

// C# program to find first element that 
// is strictly greater than given target. 
using System; 
class GfG { 
  
    private static int next(int[] arr, int target) 
    { 
        int start = 0, end = arr.Length-1; 
  
        int ans = -1; 
        while (start <= end) { 
            int mid = (start + end) / 2; 
  
            // Move to the left side if the target is smaller 
            if (arr[mid] >= target) { 
                end = mid - 1; 
            } 
  
            // Move right side 
            else { 
                ans = mid; 
                start = mid + 1; 
            } 
        } 
        return ans; 
    } 
  
    // Driver code 
    public static void Main() 
    { 
        int[] arr = { 1, 2, 3, 5, 8, 12 }; 
        Console.WriteLine(next(arr, 5)); 
    } 
} 
  
// This code is contributed by Code_Mech. 

PHP

<?php 
// PHP program to find first element that  
// is strictly greater than given target.  
    function next0($arr, $target)  
    {  
        $start = 0; $end = sizeof($arr)-1;  
  
        $ans = -1;  
        while ($start <= $end)  
        {  
            $mid =(int)(($start + $end) / 2);  
  
            // Move to the left side if the target is smaller  
            if ($arr[$mid] >= $target)  
            {  
                $end = $mid - 1;  
            }  
  
            // Move right side  
            else 
            {  
                $ans = $mid;  
                $start = $mid + 1;  
            }  
        }  
        return $ans;  
    }  
  
    // Driver code  
    {  
        $arr = array(1, 2, 3, 5, 8, 12 );  
        echo(next0($arr, 5));  
    }  
  
// This code is contributed by Code_Mech.  

Output:

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

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

C++

Java

Python3

C#

PHP

Recommended Posts: