Interpolation search vs Binary search

Last Updated : 11 Oct, 2023

Interpolation search works better than Binary Search for a Sorted and Uniformly Distributed array.

Binary Search goes to the middle element to check irrespective of search-key. On the other hand, Interpolation Search may go to different locations according to search-key. If the value of the search-key is close to the last element, Interpolation Search is likely to start search toward the end side.

Interpolation search and binary search are both algorithms for searching for a specific element in a sorted list or array. Both algorithms have an average-case time complexity of O(log n), which means that the time required to perform the search grows logarithmically with the size of the list.

However, there are some key differences between interpolation search and binary search:

Interpolation search estimates the position of the target element based on the values of the elements surrounding it, while binary search always starts by checking the middle element of the list.

Interpolation search is more efficient than binary search when the elements in the list are uniformly distributed, while binary search is more efficient when the elements in the list are not uniformly distributed.

Interpolation search can take longer to implement than binary search, as it requires the use of additional calculations to estimate the position of the target element.

Example :

C++

#include<bits/stdc++.h>
using namespace std;
 
int interpolation_search(int arr[],int target, int n){
    int low = 0;
    int high = n - 1;
 
    while (low <= high && target >= arr[low] && target <= arr[high]){
        // Calculate the position of the target element based on its value
        int pos = low + (((target - arr[low]) * (high - low)) / (arr[high] - arr[low]));
 
         // Check if the target element is at the calculated position
        if( arr[pos] == target){
            return pos;
        }
 
        // If the target element is less than the element at the calculated position, search the left half of the list
        if(arr[pos] > target){
            high = pos - 1;
        }
        else{
            // If the target element is greater than the element at the calculated position, search the right half of the list
            low = pos + 1;
        }
    }
    return -1;
}
 
int main(){
     
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 
    int n = sizeof(arr)/sizeof(int);
    int target = 5;
    int index = interpolation_search(arr, target, n);
     
    // cout << index << endl;
    if(index == -1){
        cout << target << " not found in the list" << endl;
    }
    else{
        cout << target << " found at index " << index << endl;
    }
}
 
// The code is contributed by Gautam goel. 

Java

class GFG {
  public static int interpolationSearch(int[] arr, int target) {
        int low = 0;
        int high = arr.length - 1;
 
        while (low <= high && target >= arr[low] && target <= arr[high]) {
            // Calculate the position of the target element based on its value
            int pos = low + (((target - arr[low]) * (high - low)) / (arr[high] - arr[low]));
 
            // Check if the target element is at the calculated position
            if (arr[pos] == target) {
                return pos;
            }
 
            // If the target element is less than the element at the 
            // calculated position, search the left half of the list
            if (arr[pos] > target) {
                high = pos - 1;
            } else {
                // If the target element is greater than the element 
                // at the calculated position, search the right half of the list
                low = pos + 1;
            }
        }
        return -1;
    }
   
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int target = 5;
        int index = interpolationSearch(arr, target);
 
        if (index == -1) {
            System.out.println(target + " not found in the list");
        } else {
            System.out.println(target + " found at index " + index);
        }
    }
}
 
//The code is contributed by Rohit Singh.

Python3

def interpolation_search(arr, target):
    low = 0
    high = len(arr) - 1
 
    while low <= high and target >= arr[low] and target <= arr[high]:
        # Calculate the position of the target element based on its value
        pos = low + ((target - arr[low]) * (high - low)) // (arr[high] - arr[low])
 
        # Check if the target element is at the calculated position
        if arr[pos] == target:
            return pos
 
        # If the target element is less than the element at the calculated position, search the left half of the list
        if arr[pos] > target:
            high = pos - 1
        else:
            # If the target element is greater than the element at the calculated position, search the right half of the list
            low = pos + 1
 
    return -1
 
 
def main():
    arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    target = 5
 
    index = interpolation_search(arr, target)
 
    if index == -1:
        print(f"{target} not found in the list")
    else:
        print(f"{target} found at index {index}")
 
 
if __name__ == "__main__":
    main()

C#

using System;
 
class Program
{
    static int InterpolationSearch(int[] arr, int target, int n)
    {
        int low = 0;
        int high = n - 1;
 
        while (low <= high && target >= arr[low] && target <= arr[high])
        {
            // Calculate the position of the target element based on its value
            int pos = low + (((target - arr[low]) * (high - low)) / (arr[high] - arr[low]));
 
            // Check if the target element is at the calculated position
            if (arr[pos] == target)
            {
                return pos;
            }
 
            // If the target element is less than the element at the calculated position, search the left half of the list
            if (arr[pos] > target)
            {
                high = pos - 1;
            }
            else
            {
                // If the target element is greater than the element at the calculated position, search the right half of the list
                low = pos + 1;
            }
        }
        return -1;
    }
 
    static void Main(string[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int n = arr.Length;
        int target = 5;
        int index = InterpolationSearch(arr, target, n);
 
        // Console.WriteLine(index);
        if (index == -1)
        {
            Console.WriteLine(target + " not found in the list");
        }
        else
        {
            Console.WriteLine(target + " found at index " + index);
        }
    }
}

Javascript

function interpolation_search(arr, target){
    let low = 0;
    let high = arr.length - 1;
 
    while (low <= high && target >= arr[low] && target <= arr[high]){
         
        // Calculate the position of the target element based on its value
        let pos = low + Math.floor(((target - arr[low]) * (high - low)) / (arr[high] - arr[low]));
         
        // Check if the target element is at the calculated position
        if(arr[pos] == target){
            return pos;
        }
 
        // If the target element is less than the element at the calculated position, search the left half of the list
        if(arr[pos] > target){
            high = pos - 1;
        }
        else{
            // If the target element is greater than the element at the calculated position, search the right half of the list
            low = pos + 1;
        }
    }
    return -1;
}
 
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let target = 5;
 
let index = interpolation_search(arr, target);
 
if (index == -1){
    console.log(target, " not found in the list");
}
else{
    console.log(target, " found at index ", index);
}
 
// The code is written by Nidhi goel.

Output

5 found at index 4

On average the interpolation search makes about log(log(n)) comparisons (if the elements are uniformly distributed), where n is the number of elements to be searched. In the worst case (for instance where the numerical values of the keys increase exponentially) it can make up to O(n) comparisons.

Time Complexity : O(log(log n))

space complexity : O(1)
Interpolation Search Article
Sources:
http://en.wikipedia.org/wiki/Interpolation_search