# 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 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 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 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.

## C++

// C++ program to find first element that

// is strictly greater than given target.

#include

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 right side if target is
// greater.
if (arr[mid] <= target)
start = mid + 1;
// Move left side.
else
{
ans = mid;
end = 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, 8, n);
return 0;
}
// This code is contributed by sanjeev2552
[tabby title="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 right side if target is ` ` ` `// greater. ` ` ` `if` `(arr[mid] <= target) { ` ` ` `start = mid + ` `1` `; ` ` ` `} ` ` ` ` ` `// Move left side. ` ` ` `else` `{ ` ` ` `ans = mid; ` ` ` `end = 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, ` `8` `)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

## 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 right side if target is ` ` ` `// greater. ` ` ` `if` `(arr[mid] <= target) ` ` ` `{ ` ` ` `start = mid + 1; ` ` ` `} ` ` ` ` ` `// Move left side. ` ` ` `else` ` ` `{ ` ` ` `ans = mid; ` ` ` `end = mid - 1; ` ` ` `} ` ` ` `} ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[] arr = { 1, 2, 3, 5, 8, 12 }; ` ` ` `Console.WriteLine(next(arr, 8)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Code_Mech ` |

*chevron_right*

*filter_none*

## 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 right side if target is ` ` ` `// greater. ` ` ` `if` `(` `$arr` `[` `$mid` `] <= ` `$target` `) ` ` ` `{ ` ` ` `$start` `= ` `$mid` `+ 1; ` ` ` `} ` ` ` ` ` `// Move left side. ` ` ` `else` ` ` `{ ` ` ` `$ans` `= ` `$mid` `; ` ` ` `$end` `= ` `$mid` `- 1; ` ` ` `} ` ` ` `} ` ` ` `return` `$ans` `; ` `} ` ` ` `// Driver code ` `{ ` ` ` `$arr` `= ` `array` `( 1, 2, 3, 5, 8, 12 ); ` ` ` `echo` `(next0(` `$arr` `, 8)); ` `} ` ` ` `// This code is contributed by Code_Mech ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

5

## Recommended Posts:

- First strictly smaller element in a sorted array in Java
- Find element in a sorted array whose frequency is greater than or equal to n/2.
- Check whether an array can be made strictly decreasing by modifying at most one element
- Check whether an array can be made strictly increasing by modifying atmost one element
- Length of largest sub-array having primes strictly greater than non-primes
- Find an element in an array such that elements form a strictly decreasing and increasing sequence
- Find the number of elements greater than k in a sorted array
- Closest greater element for every array element from another array
- Smallest element greater than X not present in the array
- Find closest greater value for every element in array
- Elements greater than the previous and next element in an Array
- Adding elements of an array until every element becomes greater than or equal to k
- Closest greater or same value on left side for every element in array
- Rearrange an array such that every odd indexed element is greater than it previous
- Sum of elements in an array with frequencies greater than or equal to that element

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.