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

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.

`// 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` `)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output:**

2

## Recommended Posts:

- First strictly greater element in a sorted array in Java
- Search equal, bigger or smaller in a sorted array in Java
- Count smaller elements in sorted array in C++
- Find an element in an array such that elements form a strictly decreasing and increasing sequence
- Count of smaller or equal elements in sorted array
- Find closest smaller value for every element in array
- Last duplicate element in a sorted array
- k-th missing element in sorted array
- Find the element that appears once in a sorted array
- Find first and last positions of an element in a sorted array
- Check for Majority Element in a sorted array
- Search an element in a sorted and rotated array
- Find the minimum element in a sorted and rotated array
- Find the only repeating element in a sorted array of size n
- Find index of an extra element present in one sorted array

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.