Exponential Search

14 Jun, 2022
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:  
Find range where element is presentDo Binary Search in above found range.
Find range where element is present
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
Java
Python3
C#
PHP
Javascript
// C++ program to find an element x in a// sorted array using Exponential search.#include <bits/stdc++.h>using namespace std;  int binarySearch(int arr[], int, int, int);  // Returns position of first occurrence of// x in arrayint 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 -1int 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 codeint 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++ program to find an element x in a// sorted array using Exponential search.#include <stdio.h>#include <time.h>#include <math.h>#define min  int binarySearch(int arr[], int, int, int);  // Returns position of first occurrence of// x in arrayint 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 -1int 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 codeint 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 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);    }}
# 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 -1def 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 arraydef 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 Codearr = [2, 3, 4, 10, 40]n = len(arr)x = 10result = 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# 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 arraystatic 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 -1static 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 codepublic 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// PHP program to find an element x in a// sorted array using Exponential search.  // Returns position of first // occurrence of x in arrayfunction exponentialSearch($arr, $n, $x){          // If x is present at     // first location itself    if ($arr[0] == $x)        return 0;      // Find range for binary search    // 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);}  // A recursive binary search// function. It returns location// of x in given array arr[l..r] is// present, otherwise -1function 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 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?>
<script>  // Javascript program to find an element x// in a sorted array using Exponential Search    // A recursive binary search// function. It returns location// of x in given array arr[l..r] is// present, otherwise -1function binarySearch(arr, l, r, x){    if (r >= l)    {        let 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;}   // Returns position of first// occurrence of x in arrayfunction exponentialSearch(arr, n, x){           // If x is present at     // first location itself    if (arr[0] == x)        return 0;       // Find range for binary search     // by repeated doubling    let 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);}        // Driver Code          let arr = [2, 3, 4, 10, 40];    let n = arr.length;    let x = 10;    let result = exponentialSearch(arr, n, x);    if (result == -1)         document.write("Element is not present in array");    else        document.write("Element is present at index " + result);  </script>
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: 
Exponential Binary Search is particularly useful for unbounded searches, where size of array is infinite. Please refer Unbounded Binary Search for an example.It works better than Binary Search for bounded arrays, and also when the element to be searched is closer to the first element.
Exponential Binary Search is particularly useful for unbounded searches, where size of array is infinite. Please refer Unbounded Binary Search for an example.
It works better than Binary Search for bounded arrays, and also when the element to be searched is closer to the first element.
Reference: https://en.wikipedia.org/wiki/Exponential_search
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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Anamitra Musib
vt_m
Smitha Dinesh Semwal
vsushko
nidhi_biet
ManasChhabra2
shivamtripathi91
souravghosh0416
sumitgumber28
surindertarika1234
shivanisinghss2110
sidinjnv01
surinderdawra388
amartyaghoshgfg
Binary Search
Searching
Searching
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
K'th Smallest/Largest Element in Unsorted Array | Set 1
Search an element in a sorted and rotated array
Find the Missing Number
Search, insert and delete in an unsorted array
Program to find largest element in an array
k largest(or smallest) elements in an array
Given an array of size n and a number k, find all elements that appear more than n/k times
Two Pointers Technique
Find the missing and repeating number