Open in App
Not now

# Exponential Search

• Difficulty Level : Easy
• Last Updated : 28 Mar, 2023

The name of this searching algorithm may be misleading as it works in O(Log n) time. The name comes from the way it searches an element.

```Given a sorted array, and an element x to be
searched, find position of x in the array.

Input:  arr[] = {10, 20, 40, 45, 55}
x = 45
Output: Element found at index 3

Input:  arr[] = {10, 15, 25, 45, 55}
x = 15
Output: Element found at index 1```

We have discussed, linear search, binary search for this problem.
Exponential search involves two steps:

1. Find range where element is present
2. Do Binary Search in above found range.

How to find the range where element may be present?
The idea is to start with subarray size 1, compare its last element with x, then try size 2, then 4 and so on until last element of a subarray is not greater.
Once we find an index i (after repeated doubling of i), we know that the element must be present between i/2 and i (Why i/2? because we could not find a greater value in previous iteration)
Given below are the implementations of above steps.

## C++

 `// C++ program to find an element x in a` `// sorted array using Exponential search.` `#include ` `using` `namespace` `std;`   `int` `binarySearch(``int` `arr[], ``int``, ``int``, ``int``);`   `// Returns position of first occurrence of` `// x in array` `int` `exponentialSearch(``int` `arr[], ``int` `n, ``int` `x)` `{` `    ``// If x is present at first location itself` `    ``if` `(arr[0] == x)` `        ``return` `0;`   `    ``// Find range for binary search by` `    ``// repeated doubling` `    ``int` `i = 1;` `    ``while` `(i < n && arr[i] <= x)` `        ``i = i*2;`   `    ``//  Call binary search for the found range.` `    ``return` `binarySearch(arr, i/2, ` `                            ``min(i, n-1), x);` `}`   `// A recursive binary search function. It returns` `// location of x in  given array arr[l..r] is` `// present, otherwise -1` `int` `binarySearch(``int` `arr[], ``int` `l, ``int` `r, ``int` `x)` `{` `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l)/2;`   `        ``// If the element is present at the middle` `        ``// itself` `        ``if` `(arr[mid] == x)` `            ``return` `mid;`   `        ``// If element is smaller than mid, then it` `        ``// can only be present n left subarray` `        ``if` `(arr[mid] > x)` `            ``return` `binarySearch(arr, l, mid-1, x);`   `        ``// Else the element can only be present` `        ``// in right subarray` `        ``return` `binarySearch(arr, mid+1, r, x);` `    ``}`   `    ``// We reach here when element is not present` `    ``// in array` `    ``return` `-1;` `}`   `// Driver code` `int` `main(``void``)` `{` `   ``int` `arr[] = {2, 3, 4, 10, 40};` `   ``int` `n = ``sizeof``(arr)/ ``sizeof``(arr[0]);` `   ``int` `x = 10;` `   ``int` `result = exponentialSearch(arr, n, x);` `   ``(result == -1)? cout <<``"Element is not present in array"` `                 ``: cout <<``"Element is present at index "` `<< result;` `   ``return` `0;` `}`   `// this code is contributed by shivanisinghss2110`

## C

 `// C++ program to find an element x in a` `// sorted array using Exponential search.` `#include ` `#include ` `#include ` `#define min`   `int` `binarySearch(``int` `arr[], ``int``, ``int``, ``int``);`   `// Returns position of first occurrence of` `// x in array` `int` `exponentialSearch(``int` `arr[], ``int` `n, ``int` `x)` `{` `    ``// If x is present at first location itself` `    ``if` `(arr[0] == x)` `        ``return` `0;`   `    ``// Find range for binary search by` `    ``// repeated doubling` `    ``int` `i = 1;` `    ``while` `(i < n && arr[i] <= x)` `        ``i = i*2;`   `    ``//  Call binary search for the found range.` `    ``return` `binarySearch(arr, i/2, ` `                            ``min(i, n-1), x);` `}`   `// A recursive binary search function. It returns` `// location of x in  given array arr[l..r] is` `// present, otherwise -1` `int` `binarySearch(``int` `arr[], ``int` `l, ``int` `r, ``int` `x)` `{` `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l)/2;`   `        ``// If the element is present at the middle` `        ``// itself` `        ``if` `(arr[mid] == x)` `            ``return` `mid;`   `        ``// If element is smaller than mid, then it` `        ``// can only be present n left subarray` `        ``if` `(arr[mid] > x)` `            ``return` `binarySearch(arr, l, mid-1, x);`   `        ``// Else the element can only be present` `        ``// in right subarray` `        ``return` `binarySearch(arr, mid+1, r, x);` `    ``}`   `    ``// We reach here when element is not present` `    ``// in array` `    ``return` `-1;` `}`   `// Driver code` `int` `main(``void``)` `{` `   ``int` `arr[] = {2, 3, 4, 10, 40};` `   ``int` `n = ``sizeof``(arr)/ ``sizeof``(arr[0]);` `   ``int` `x = 10;` `   ``int` `result = exponentialSearch(arr, n, x);` `   ``(result == -1)? ``printf``("Element is not ` `                            ``present in array")` `                 ``: ``printf``("Element is present ` `                                 ``at index %d",` `                                       ``result);` `   ``return` `0;` `}`

## Java

 `// Java program to ` `// find an element x in a` `// sorted array using ` `// Exponential search.` `import` `java.util.Arrays;`   `class` `GFG` `{` `    ``// Returns position of ` `    ``// first occurrence of` `    ``// x in array` `    ``static` `int` `exponentialSearch(``int` `arr[],` `                                 ``int` `n, ``int` `x)` `    ``{` `        ``// If x is present at first location itself` `        ``if` `(arr[``0``] == x)` `            ``return` `0``;` `    `  `        ``// Find range for binary search by` `        ``// repeated doubling` `        ``int` `i = ``1``;` `        ``while` `(i < n && arr[i] <= x)` `            ``i = i*``2``;` `    `  `        ``// Call binary search for the found range.` `        ``return` `Arrays.binarySearch(arr, i/``2``, ` `                              ``Math.min(i, n-``1``), x);` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `arr[] = {``2``, ``3``, ``4``, ``10``, ``40``};` `        ``int` `x = ``10``;` `        ``int` `result = exponentialSearch(arr, ` `                                  ``arr.length, x);` `        `  `        ``System.out.println((result < ``0``) ? ` `          ``"Element is not present in array"` `:` `          ``"Element is present at index "` `+ ` `                             ``result);` `    ``}` `}`

## Python3

 `# Python program to find an element x` `# in a sorted array using Exponential Search`   `# A recursive binary search function returns ` `# location  of x in given array arr[l..r] is ` `# present, otherwise -1` `def` `binarySearch( arr, l, r, x):` `    ``if` `r >``=` `l:` `        ``mid ``=` `l ``+` `( r``-``l ) ``/``/` `2` `        `  `        ``# If the element is present at ` `        ``# the middle itself` `        ``if` `arr[mid] ``=``=` `x:` `            ``return` `mid` `        `  `        ``# If the element is smaller than mid, ` `        ``# then it can only be present in the ` `        ``# left subarray` `        ``if` `arr[mid] > x:` `            ``return` `binarySearch(arr, l, ` `                                ``mid ``-` `1``, x)` `        `  `        ``# Else he element can only be` `        ``# present in the right` `        ``return` `binarySearch(arr, mid ``+` `1``, r, x)` `        `  `    ``# We reach here if the element is not present` `    ``return` `-``1`   `# Returns the position of first` `# occurrence of x in array` `def` `exponentialSearch(arr, n, x):` `    ``# IF x is present at first ` `    ``# location itself` `    ``if` `arr[``0``] ``=``=` `x:` `        ``return` `0` `        `  `    ``# Find range for binary search ` `    ``# j by repeated doubling` `    ``i ``=` `1` `    ``while` `i < n ``and` `arr[i] <``=` `x:` `        ``i ``=` `i ``*` `2` `    `  `    ``# Call binary search for the found range` `    ``return` `binarySearch( arr, i ``/``/` `2``, ` `                         ``min``(i, n``-``1``), x)` `    `    `# Driver Code` `arr ``=` `[``2``, ``3``, ``4``, ``10``, ``40``]` `n ``=` `len``(arr)` `x ``=` `10` `result ``=` `exponentialSearch(arr, n, x)` `if` `result ``=``=` `-``1``:` `    ``print` `(``"Element not found in the array"``)` `else``:` `    ``print` `(``"Element is present at index %d"` `%``(result))`   `# This code is contributed by Harshit Agrawal`

## C#

 `// C# program to find an element x in a` `// sorted array using Exponential search.` `using` `System;` `class` `GFG {`   `// Returns position of first` `// occurrence of x in array` `static` `int` `exponentialSearch(``int` `[]arr, ` `                         ``int` `n, ``int` `x)` `{` `    `  `    ``// If x is present at ` `    ``// first location itself` `    ``if` `(arr[0] == x)` `        ``return` `0;`   `    ``// Find range for binary search ` `    ``// by repeated doubling` `    ``int` `i = 1;` `    ``while` `(i < n && arr[i] <= x)` `        ``i = i * 2;`   `    ``// Call binary search for` `    ``// the found range.` `    ``return` `binarySearch(arr, i/2, ` `                       ``Math.Min(i, n - 1), x);` `}`   `// A recursive binary search` `// function. It returns location` `// of x in given array arr[l..r] is` `// present, otherwise -1` `static` `int` `binarySearch(``int` `[]arr, ``int` `l,` `                        ``int` `r, ``int` `x)` `{` `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l) / 2;`   `        ``// If the element is present` `        ``// at the middle itself` `        ``if` `(arr[mid] == x)` `            ``return` `mid;`   `        ``// If element is smaller than` `        ``// mid, then it can only be ` `        ``// present n left subarray` `        ``if` `(arr[mid] > x)` `            ``return` `binarySearch(arr, l, mid - 1, x);`   `        ``// Else the element can only ` `        ``// be present in right subarray` `        ``return` `binarySearch(arr, mid + 1, r, x);` `    ``}`   `    ``// We reach here when element` `    ``// is not present in array` `    ``return` `-1;` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = {2, 3, 4, 10, 40};` `    ``int` `n = arr.Length;` `    ``int` `x = 10;` `    ``int` `result = exponentialSearch(arr, n, x);` `    ``if` `(result == -1)` `            ``Console.Write("Element ``is` `not ` `                          ``present ``in` `array");` `        ``else` `            ``Console.Write("Element ``is` `                           ``present at index " ` `                                   ``+ result);` `}` `}`   `// This code is contributed by Smitha`

## PHP

 `= ``\$l``)` `    ``{` `        ``\$mid` `= ``\$l` `+ (``\$r` `- ``\$l``)/2;`   `        ``// If the element is` `        ``// present at the middle` `        ``// itself` `        ``if` `(``\$arr``[``\$mid``] == ``\$x``)` `            ``return` `\$mid``;`   `        ``// If element is smaller` `        ``// than mid, then it` `        ``// can only be present ` `        ``// n left subarray` `        ``if` `(``\$arr``[``\$mid``] > ``\$x``)` `            ``return` `binarySearch(``\$arr``, ``\$l``, ` `                                ``\$mid` `- 1, ``\$x``);`   `        ``// Else the element ` `        ``// can only be present` `        ``// in right subarray` `        ``return` `binarySearch(``\$arr``, ``\$mid` `+ 1,` `                                    ``\$r``, ``\$x``);` `    ``}`   `    ``// We reach here when` `    ``// element is not present` `    ``// in array` `    ``return` `-1;` `}`   `// Driver code` `\$arr` `= ``array``(2, 3, 4, 10, 40);` `\$n` `= ``count``(``\$arr``);` `\$x` `= 10;` `\$result` `= exponentialSearch(``\$arr``, ``\$n``, ``\$x``);` `if``(``\$result` `== -1)` `    ``echo` `"Element is not present in array"``;` `else` `    ``echo` `"Element is present at index "``,` `                                ``\$result``;`   `// This code is contributed by anuj_67` `?>`

## Javascript

 ``

Output

`Element is present at index 3`

Time Complexity : O(Log n)
Auxiliary Space : The above implementation of Binary Search is recursive and requires O(Log n) space. With iterative Binary Search, we need only O(1) space.
Applications of Exponential Search:

1. Exponential Binary Search is particularly useful for unbounded searches, where size of array is infinite. Please refer Unbounded Binary Search for an example.
2. It works better than Binary Search for bounded arrays, and also when the element to be searched is closer to the first element.

This article is contributed by Pankaj Sharma. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Approach 2: Iterative implementation

Here’s how it works:

We start with an index i equal to 1 and repeatedly double it until either i is greater than or equal to the length of the array or the value at index i is greater than or equal to the target value x.
We then perform a binary search on the range [i/2, min(i, n-1)], where n is the length of the array. This range is guaranteed to contain the target value, if it is present in the array, because we know that the target value must be greater than or equal to the value at index i/2 and less than or equal to the value at index min(i, n-1).
If we find the target value in the binary search, we return its index. Otherwise, we return -1 to indicate that the target value is not present in the array.

## C++

 `#include` `using` `namespace` `std;`     `int` `exponential_search(vector<``int``> arr,``int` `x){` `    ``int` `n = arr.size();` `    `  `    ``if``(n == 0)` `        ``return` `-1;`   `    ``// Find range for binary search by repeatedly doubling i` `    ``int` `i = 1;` `    ``while``(i < n and arr[i] < x)` `        ``i *= 2;`   `    ``// Perform binary search on the range [i/2, min(i, n-1)]` `    ``int` `left = i /2;` `    ``int` `right = min(i, n-1);`   `    ``while``(left <= right){` `        ``int` `mid = (left + right)/2;` `        `  `        ``if``(arr[mid] == x) ``return` `mid;` `        ``else` `if``(arr[mid] < x) left = mid + 1;` `        ``else` `right = mid - 1;` `    ``}`   `    ``return` `-1;` `}` `    `    `// Driver Code` `int` `main(){` `    `  `    ``vector<``int``> arr = {2, 3, 4, 10, 40};` `    ``int` `n = arr.size();` `    ``int` `x = 10;` `    ``int` `result = exponential_search(arr, x);` `    `  `    ``if``(result == -1){` `        ``cout << ``"Element not found in the array"``;` `    ``}` `    ``else``{` `        ``cout << ``"Element is present at index "` `<< result << endl;` `    ``}` `    ``return` `0;` `}`   `// This code is contributed by Ajay singh`

## Java

 `// Java implementation of above approach` `import` `java.util.*;`   `class` `Main {` `  `  `  ``// Exponential search function` `    ``public` `static` `int` `exponential_search(ArrayList arr, ``int` `x) {` `    ``int` `n = arr.size();` `    `  `    ``if` `(n == ``0``)` `        ``return` `-``1``;` `    `  `    ``// Find range for binary search by repeatedly doubling i` `    ``int` `i = ``1``;` `    ``while` `(i < n && arr.get(i) < x)` `        ``i *= ``2``;` `    `  `    ``// Perform binary search on the range [i/2, min(i, n-1)]` `    ``int` `left = i / ``2``;` `    ``int` `right = Math.min(i, n - ``1``);` `    `  `    ``while` `(left <= right) {` `        ``int` `mid = (left + right) / ``2``;  ``// finding mid` `        `  `        ``if` `(arr.get(mid) == x)` `            ``return` `mid;` `        ``else` `if` `(arr.get(mid) < x)` `            ``left = mid + ``1``;` `        ``else` `            ``right = mid - ``1``;` `    ``}` `    `  `    ``return` `-``1``;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) {` `    ``ArrayList arr = ``new` `ArrayList<>(Arrays.asList(``2``, ``3``, ``4``, ``10``, ``40``));` `    ``int` `n = arr.size();` `    ``int` `x = ``10``;` `    ``int` `result = exponential_search(arr, x);` `    `  `    ``if` `(result == -``1``) {` `        ``System.out.println(``"Element not found in the array"``);` `    ``}` `    ``else` `{` `        ``System.out.println(``"Element is present at index "` `+ result);` `    ``}` `}`   `}`

## Python

 `def` `exponential_search(arr, x):` `    ``n ``=` `len``(arr)` `    ``if` `n ``=``=` `0``:` `        ``return` `-``1`   `    ``# Find range for binary search by repeatedly doubling i` `    ``i ``=` `1` `    ``while` `i < n ``and` `arr[i] < x:` `        ``i ``*``=` `2`   `    ``# Perform binary search on the range [i/2, min(i, n-1)]` `    ``left ``=` `i ``/``/` `2` `    ``right ``=` `min``(i, n``-``1``)`   `    ``while` `left <``=` `right:` `        ``mid ``=` `(left ``+` `right) ``/``/` `2` `        ``if` `arr[mid] ``=``=` `x:` `            ``return` `mid` `        ``elif` `arr[mid] < x:` `            ``left ``=` `mid ``+` `1` `        ``else``:` `            ``right ``=` `mid ``-` `1`   `    ``return` `-``1`   `    `    `# Driver Code` `arr ``=` `[``2``, ``3``, ``4``, ``10``, ``40``]` `n ``=` `len``(arr)` `x ``=` `10` `result ``=` `exponential_search(arr, x)` `if` `result ``=``=` `-``1``:` `    ``print` `(``"Element not found in the array"``)` `else``:` `    ``print` `(``"Element is present at index %d"` `%``(result))`   `# This code is contributed by Ajay singh`

## C#

 `// C# Program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `Program` `{` `    ``static` `int` `exponential_search(List<``int``> arr, ``int` `x)` `    ``{` `        ``int` `n = arr.Count;`   `        ``if` `(n == 0)` `            ``return` `-1;`   `        ``// Find range for binary search by repeatedly doubling i` `        ``int` `i = 1;` `        ``while` `(i < n && arr[i] < x)` `            ``i *= 2;`   `        ``// Perform binary search on the range [i/2, min(i, n-1)]` `        ``int` `left = i / 2;` `        ``int` `right = Math.Min(i, n - 1);`   `        ``while` `(left <= right)` `        ``{` `            ``int` `mid = (left + right) / 2;`   `            ``if` `(arr[mid] == x) ``return` `mid;` `            ``else` `if` `(arr[mid] < x) left = mid + 1;` `            ``else` `right = mid - 1;` `        ``}`   `        ``return` `-1;` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``List<``int``> arr = ``new` `List<``int``> { 2, 3, 4, 10, 40 };` `        ``int` `n = arr.Count;` `        ``int` `x = 10;` `        ``int` `result = exponential_search(arr, x);`   `        ``if` `(result == -1)` `        ``{` `            ``Console.WriteLine(``"Element not found in the array"``);` `        ``}` `        ``else` `        ``{` `            ``Console.WriteLine(``"Element is present at index "` `+ result);` `        ``}` `    ``}` `}`   `// This code is contributed by princekumaras`

## Javascript

 `function` `exponential_search(arr, x) {` `  ``const n = arr.length;` `  ``if` `(n == 0) { ``// if array is empty, return -1` `    ``return` `-1;` `  ``}`   `  ``let i = 1;` `  ``while` `(i < n && arr[i] < x) { ``// Find the range for binary search by repeatedly doubling i` `    ``i *= 2;` `  ``}`   `  ``const left = Math.floor(i / 2); ``// Set left boundary for binary search` `  ``const right = Math.min(i, n - 1); ``// Set right boundary for binary search`   `  ``while` `(left <= right) { ``// Perform binary search on the range [i/2, min(i, n-1)]` `    ``const mid = Math.floor((left + right) / 2); ``// Find middle index` `    ``if` `(arr[mid] == x) { ``// If element is found at mid index, return mid` `      ``return` `mid;` `    ``} ``else` `if` `(arr[mid] < x) { ``// If element is less than mid index, search the right half of array` `      ``left = mid + 1;` `    ``} ``else` `{ ``// If element is greater than mid index, search the left half of array` `      ``right = mid - 1;` `    ``}` `  ``}`   `  ``return` `-1; ``// If element is not found in array, return -1` `}`   `// Driver Code` `const arr = [2, 3, 4, 10, 40];` `const n = arr.length;` `const x = 10;` `const result = exponential_search(arr, x);` `if` `(result == -1) {` `  ``console.log(``"Element not found in the array"``);` `} ``else` `{` `  ``console.log(`Element is present at index \${result}`);` `}`

Output

`Element is present at index 3`

Time Complexity : O(Log n)
Auxiliary Space :  O(1) space.

My Personal Notes arrow_drop_up
Related Articles