First strictly greater element in a sorted array in Java
Given a sorted array and a target value, find the first element that is strictly greater than given element.
Examples:
Input : arr[] = {1, 2, 3, 5, 8, 12}
Target = 5
Output : 4 (Index of 8)
Input : {1, 2, 3, 5, 8, 12}
Target = 8
Output : 5 (Index of 12)
Input : {1, 2, 3, 5, 8, 12}
Target = 15
Output : -1
A simple solution is to linearly traverse the given array and find the 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 that 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 no greater than the target element, then it and everything below it can’t possibly match, so there’s no need to search that region. We can thus search for the right half. If we find an element that is larger than the element in question, then anything after it must also be larger, so they can’t be the first element that’s bigger 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 greater than the target in O(lg n) iterations of this process.
Implementation:
C++
#include <iostream>
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;
if (arr[mid] <= target)
start = mid + 1;
else
{
ans = mid;
end = mid - 1;
}
}
return ans;
}
int main()
{
int arr[] = {1, 2, 3, 5, 8, 12};
int n = sizeof (arr) / sizeof (arr[0]);
cout << next(arr, 8, n-1);
return 0;
}
|
Java
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 ;
if (arr[mid] <= target) {
start = mid + 1 ;
}
else {
ans = mid;
end = mid - 1 ;
}
}
return ans;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 5 , 8 , 12 };
System.out.println(next(arr, 8 ));
}
}
|
Python3
def next (arr, target):
start = 0 ;
end = len (arr) - 1 ;
ans = - 1 ;
while (start < = end):
mid = (start + end) / / 2 ;
if (arr[mid] < = target):
start = mid + 1 ;
else :
ans = mid;
end = mid - 1 ;
return ans;
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 5 , 8 , 12 ];
print ( next (arr, 8 ));
|
C#
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;
if (arr[mid] <= target)
{
start = mid + 1;
}
else
{
ans = mid;
end = mid - 1;
}
}
return ans;
}
public static void Main()
{
int [] arr = { 1, 2, 3, 5, 8, 12 };
Console.WriteLine(next(arr, 8));
}
}
|
PHP
<?php
function next0( $arr , $target )
{
$start = 0; $end = sizeof( $arr ) - 1;
$ans = -1;
while ( $start <= $end )
{
$mid = (int)(( $start + $end ) / 2);
if ( $arr [ $mid ] <= $target )
{
$start = $mid + 1;
}
else
{
$ans = $mid ;
$end = $mid - 1;
}
}
return $ans ;
}
{
$arr = array ( 1, 2, 3, 5, 8, 12 );
echo (next0( $arr , 8));
}
?>
|
Javascript
<script>
function next(arr, target)
{
let start = 0, end = arr.length - 1;
let ans = -1;
while (start <= end)
{
let mid = parseInt((start + end) / 2, 10);
if (arr[mid] <= target)
{
start = mid + 1;
}
else
{
ans = mid;
end = mid - 1;
}
}
return ans;
}
let arr = [ 1, 2, 3, 5, 8, 12 ];
document.write(next(arr, 8));
</script>
|
Time Complexity: O(log(n))
Auxiliary Space: O(1)
Last Updated :
15 Nov, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...