Exponential Search

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 array
int exponentialSearch(int arr[], int n, int x)
{
    // If x is present at firt 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), 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 firt 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), 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); 


    } 


} 



















                        chevron_right







                        filter_none









Python














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python program to find an element x 


# in a sorted array using Exponential Search 


  


# A recurssive 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 


# occurence 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), 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 thye array"


else: 


    print "Element is present at index %d" %(result) 


  


# This code is contributed by Harshit Agrawal 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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), 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 



















                        chevron_right







                        filter_none









PHP














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















<?php 


// PHP program to find an element x in a 


// sorted array using Exponential search. 


  


// Returns position of first  


// occurrence of x in array 


function 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), $x); 


} 


  


// A recursive binary search 


// function. It returns location 


// of x in given array arr[l..r] is 


// present, otherwise -1 


function 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 


?> 



















                        chevron_right







                        filter_none










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. 

  2. It works better than Binary Search for bounded arrays, and also when the element to be searched is closer to the first element.
    3. 



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 contribute@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



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts: