Search an element in a sorted and rotated array

An element in a sorted array can be found in O(log n) time via binary search. But suppose we rotate an ascending order sorted array at some pivot unknown to you beforehand. So for instance, 1 2 3 4 5 might become 3 4 5 1 2. Devise a way to find an element in the rotated array in O(log n) time.

Input  : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
         key = 3
Output : Found at index 8

Input  : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
         key = 30
Output : Not found

Input : arr[] = {30, 40, 50, 10, 20}
        key = 10   
Output : Found at index 3

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

All solutions provided here assume that all elements in array are distinct.

The idea is to find the pivot point, divide the array in two sub-arrays and call binary search.
The main idea for finding pivot is – for a sorted (in increasing order) and pivoted array, pivot element is the only element for which next element to it is smaller than it.
Using above criteria and binary search methodology we can get pivot element in O(logn) time

Input arr[] = {3, 4, 5, 1, 2}
Element to Search = 1
  1) Find out pivot point and divide the array in two
      sub-arrays. (pivot = 2) /*Index of 5*/
  2) Now call binary search for one of the two sub-arrays.
      (a) If element is greater than 0th element then
             search in left array
      (b) Else Search in right array
          (1 will go in else as 1 < 0th element(3))
  3) If element is found in selected sub-array then return index
     Else return -1.

Below is the implementation of the above approach :

C++

/* C++ Program to search an element 
   in a sorted and pivoted array*/
#include <bits/stdc++.h> 
using namespace std; 
  
/* Standard Binary Search function*/
int binarySearch(int arr[], int low,  
                  int high, int key) 
{ 
  if (high < low) 
    return -1; 
      
  int mid = (low + high)/2; /*low + (high - low)/2;*/
  if (key == arr[mid]) 
    return mid; 
      
  if (key > arr[mid]) 
    return binarySearch(arr, (mid + 1), high, key); 
      
  // else 
    return binarySearch(arr, low, (mid -1), key); 
} 
  
/* Function to get pivot. For array 3, 4, 5, 6, 1, 2 
   it returns 3 (index of 6) */
int findPivot(int arr[], int low, int high) 
{ 
  // base cases 
  if (high < low) return -1; 
  if (high == low) return low; 
  
   int mid = (low + high)/2; /*low + (high - low)/2;*/
   if (mid < high && arr[mid] > arr[mid + 1]) 
    return mid; 
      
   if (mid > low && arr[mid] < arr[mid - 1]) 
    return (mid-1); 
      
   if (arr[low] >= arr[mid]) 
    return findPivot(arr, low, mid-1); 
      
   return findPivot(arr, mid + 1, high); 
} 
  
/* Searches an element key in a pivoted 
   sorted array arr[] of size n */
int pivotedBinarySearch(int arr[], int n, int key) 
{ 
  int pivot = findPivot(arr, 0, n-1); 
  
  // If we didn't find a pivot,  
  // then array is not rotated at all 
  if (pivot == -1) 
    return binarySearch(arr, 0, n-1, key); 
  
  // If we found a pivot, then first compare with pivot 
  // and then search in two subarrays around pivot 
  if (arr[pivot] == key) 
    return pivot; 
      
  if (arr[0] <= key) 
    return binarySearch(arr, 0, pivot-1, key); 
      
    return binarySearch(arr, pivot+1, n-1, key); 
} 
  
/* Driver program to check above functions */
int main() 
{ 
  // Let us search 3 in below array 
  int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3}; 
  int n = sizeof(arr1)/sizeof(arr1[0]); 
  int key = 3; 
    
  // Function calling 
  cout << "Index of the element is : " <<  
           pivotedBinarySearch(arr1, n, key); 
             
  return 0; 
} 

C

/* Program to search an element in a sorted and pivoted array*/
#include <stdio.h> 
  
int findPivot(int[], int, int); 
int binarySearch(int[], int, int, int); 
  
/* Searches an element key in a pivoted sorted array arrp[] 
   of size n */
int pivotedBinarySearch(int arr[], int n, int key) 
{ 
   int pivot = findPivot(arr, 0, n-1); 
  
   // If we didn't find a pivot, then array is not rotated at all 
   if (pivot == -1) 
       return binarySearch(arr, 0, n-1, key); 
  
   // If we found a pivot, then first compare with pivot and then 
   // search in two subarrays around pivot 
   if (arr[pivot] == key) 
       return pivot; 
   if (arr[0] <= key) 
       return binarySearch(arr, 0, pivot-1, key); 
   return binarySearch(arr, pivot+1, n-1, key); 
} 
  
/* Function to get pivot. For array 3, 4, 5, 6, 1, 2 it returns 
   3 (index of 6) */
int findPivot(int arr[], int low, int high) 
{ 
   // base cases 
   if (high < low)  return -1; 
   if (high == low) return low; 
  
   int mid = (low + high)/2;   /*low + (high - low)/2;*/
   if (mid < high && arr[mid] > arr[mid + 1]) 
       return mid; 
   if (mid > low && arr[mid] < arr[mid - 1]) 
       return (mid-1); 
   if (arr[low] >= arr[mid]) 
       return findPivot(arr, low, mid-1); 
   return findPivot(arr, mid + 1, high); 
} 
  
/* Standard Binary Search function*/
int binarySearch(int arr[], int low, int high, int key) 
{ 
   if (high < low) 
       return -1; 
   int mid = (low + high)/2;  /*low + (high - low)/2;*/
   if (key == arr[mid]) 
       return mid; 
   if (key > arr[mid]) 
       return binarySearch(arr, (mid + 1), high, key); 
   return binarySearch(arr, low, (mid -1), key); 
} 
  
/* Driver program to check above functions */
int main() 
{ 
   // Let us search 3 in below array 
   int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3}; 
   int n = sizeof(arr1)/sizeof(arr1[0]); 
   int key = 3; 
   printf("Index of the element is : %d", 
        pivotedBinarySearch(arr1, n, key)); 
   return 0; 
} 

Java

/* Java program to search an element  
   in a sorted and pivoted array*/
   
class Main 
{ 
           
    /* Searches an element key in a  
       pivoted sorted array arrp[] 
       of size n */
    static int pivotedBinarySearch(int arr[], int n, int key) 
    { 
       int pivot = findPivot(arr, 0, n-1); 
        
       // If we didn't find a pivot, then  
       // array is not rotated at all 
       if (pivot == -1) 
           return binarySearch(arr, 0, n-1, key); 
        
       // If we found a pivot, then first  
       // compare with pivot and then 
       // search in two subarrays around pivot 
       if (arr[pivot] == key) 
           return pivot; 
       if (arr[0] <= key) 
           return binarySearch(arr, 0, pivot-1, key); 
       return binarySearch(arr, pivot+1, n-1, key); 
    } 
       
    /* Function to get pivot. For array  
       3, 4, 5, 6, 1, 2 it returns 
       3 (index of 6) */
    static int findPivot(int arr[], int low, int high) 
    { 
       // base cases 
       if (high < low)   
            return -1; 
       if (high == low)  
            return low; 
         
       /* low + (high - low)/2; */
       int mid = (low + high)/2;    
       if (mid < high && arr[mid] > arr[mid + 1]) 
           return mid; 
       if (mid > low && arr[mid] < arr[mid - 1]) 
           return (mid-1); 
       if (arr[low] >= arr[mid]) 
           return findPivot(arr, low, mid-1); 
       return findPivot(arr, mid + 1, high); 
    } 
       
    /* Standard Binary Search function */
    static int binarySearch(int arr[], int low, int high, int key) 
    { 
       if (high < low) 
           return -1; 
         
       /* low + (high - low)/2; */       
       int mid = (low + high)/2;   
       if (key == arr[mid]) 
           return mid; 
       if (key > arr[mid]) 
           return binarySearch(arr, (mid + 1), high, key); 
       return binarySearch(arr, low, (mid -1), key); 
    } 
    
    // main function 
    public static void main(String args[]) 
    { 
       // Let us search 3 in below array 
       int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3}; 
       int n = arr1.length; 
       int key = 3; 
       System.out.println("Index of the element is : "
                      + pivotedBinarySearch(arr1, n, key)); 
    } 
} 

Python3

# Python Program to search an element 
# in a sorted and pivoted array 
  
# Searches an element key in a pivoted 
# sorted array arrp[] of size n  
def pivotedBinarySearch(arr, n, key): 
  
    pivot = findPivot(arr, 0, n-1); 
  
    # If we didn't find a pivot,  
    # then array is not rotated at all 
    if pivot == -1: 
        return binarySearch(arr, 0, n-1, key); 
  
    # If we found a pivot, then first 
    # compare with pivot and then 
    # search in two subarrays around pivot 
    if arr[pivot] == key: 
        return pivot 
    if arr[0] <= key: 
        return binarySearch(arr, 0, pivot-1, key); 
    return binarySearch(arr, pivot+1, n-1, key); 
  
  
# Function to get pivot. For array  
# 3, 4, 5, 6, 1, 2 it returns 3  
# (index of 6)  
def findPivot(arr, low, high): 
      
    # base cases 
    if high < low: 
        return -1
    if high == low: 
        return low 
      
    #low + (high - low)/2; 
    mid = int((low + high)/2) 
      
    if mid < high and arr[mid] > arr[mid + 1]: 
        return mid 
    if mid > low and arr[mid] < arr[mid - 1]: 
        return (mid-1) 
    if arr[low] >= arr[mid]: 
        return findPivot(arr, low, mid-1) 
    return findPivot(arr, mid + 1, high) 
  
# Standard Binary Search function*/ 
def binarySearch(arr, low, high, key): 
  
    if high < low: 
        return -1
          
    #low + (high - low)/2;     
    mid = int((low + high)/2) 
      
    if key == arr[mid]: 
        return mid 
    if key > arr[mid]: 
        return binarySearch(arr, (mid + 1), high, 
                                            key); 
    return binarySearch(arr, low, (mid -1), key); 
  
  
# Driver program to check above functions */ 
# Let us search 3 in below array 
arr1 = [5, 6, 7, 8, 9, 10, 1, 2, 3] 
n = len(arr1) 
key = 3
print("Index of the element is : ",  
      pivotedBinarySearch(arr1, n, key)) 
        
# This is contributed by Smitha Dinesh Semwal 

C#

// C# program to search an element 
// in a sorted and pivoted array 
using System; 
  
class main { 
  
    // Searches an element key in a 
    // pivoted sorted array arrp[] 
    // of size n 
    static int pivotedBinarySearch(int[] arr, 
                                int n, int key) 
    { 
        int pivot = findPivot(arr, 0, n - 1); 
  
        // If we didn't find a pivot, then 
        // array is not rotated at all 
        if (pivot == -1) 
            return binarySearch(arr, 0, n - 1, key); 
  
        // If we found a pivot, then first 
        // compare with pivot and then 
        // search in two subarrays around pivot 
        if (arr[pivot] == key) 
            return pivot; 
  
        if (arr[0] <= key) 
            return binarySearch(arr, 0, pivot - 1, key); 
  
        return binarySearch(arr, pivot + 1, n - 1, key); 
    } 
  
    /* Function to get pivot. For array  
    3, 4, 5, 6, 1, 2 it returns 
    3 (index of 6) */
    static int findPivot(int[] arr, int low, int high) 
    { 
        // base cases 
        if (high < low) 
            return -1; 
        if (high == low) 
            return low; 
  
        /* low + (high - low)/2; */
        int mid = (low + high) / 2; 
  
        if (mid < high && arr[mid] > arr[mid + 1]) 
            return mid; 
  
        if (mid > low && arr[mid] < arr[mid - 1]) 
            return (mid - 1); 
  
        if (arr[low] >= arr[mid]) 
            return findPivot(arr, low, mid - 1); 
  
        return findPivot(arr, mid + 1, high); 
    } 
  
    /* Standard Binary Search function */
    static int binarySearch(int[] arr, int low, 
                            int high, int key) 
    { 
        if (high < low) 
            return -1; 
  
        /* low + (high - low)/2; */
        int mid = (low + high) / 2; 
  
        if (key == arr[mid]) 
            return mid; 
        if (key > arr[mid]) 
            return binarySearch(arr, (mid + 1), high, key); 
  
        return binarySearch(arr, low, (mid - 1), key); 
    } 
  
    // Driver Code 
    public static void Main() 
    { 
        // Let us search 3 in below array 
        int[] arr1 = { 5, 6, 7, 8, 9, 10, 1, 2, 3 }; 
        int n = arr1.Length; 
        int key = 3; 
        Console.Write("Index of the element is : "
                    + pivotedBinarySearch(arr1, n, key)); 
    } 
} 
  
// This code is contributed by vt_m. 

PHP

<?php 
// PHP Program to search an element 
// in a sorted and pivoted array 
  
// Standard Binary Search function 
function binarySearch($arr, $low,  
                      $high, $key) 
{ 
    if ($high < $low) 
        return -1; 
          
    /*low + (high - low)/2;*/    
    $mid = floor($low + $high) / 2; 
      
    if ($key == $arr[$mid]) 
        return $mid; 
          
    if ($key > $arr[$mid]) 
        return binarySearch($arr, ($mid + 1), 
                                $high, $key); 
          
    else
        return binarySearch($arr, $low, 
                      ($mid -1), $key); 
} 
  
// Function to get pivot.  
// For array 3, 4, 5, 6, 1, 2 
// it returns 3 (index of 6) 
function findPivot($arr, $low, $high) 
{ 
      
    // base cases 
    if ($high < $low)  
        return -1; 
    if ($high == $low)  
        return $low; 
      
    /*low + (high - low)/2;*/
    $mid = ($low + $high)/2;  
    if ($mid < $high and $arr[$mid] >  
                     $arr[$mid + 1]) 
        return $mid; 
          
    if ($mid > $low and $arr[$mid] <  
                    $arr[$mid - 1]) 
        return ($mid - 1); 
          
    if ($arr[$low] >= $arr[$mid]) 
        return findPivot($arr, $low, 
                          $mid - 1); 
          
    return findPivot($arr, $mid + 1, $high); 
} 
  
// Searches an element key 
// in a pivoted sorted array 
// arr[] of size n */ 
function pivotedBinarySearch($arr, $n, $key) 
{ 
    $pivot = findPivot($arr, 0, $n - 1); 
      
    // If we didn't find a pivot,  
    // then array is not rotated 
    // at all 
    if ($pivot == -1) 
        return binarySearch($arr, 0,  
                       $n - 1, $key); 
      
    // If we found a pivot,  
    // then first compare 
    // with pivot and then  
    // search in two subarrays 
    // around pivot 
    if ($arr[$pivot] == $key) 
        return $pivot; 
          
    if ($arr[0] <= $key) 
        return binarySearch($arr, 0,  
                   $pivot - 1, $key); 
          
        return binarySearch($arr, $pivot + 1,  
                                $n - 1, $key); 
} 
  
// Driver Code 
// Let us search 3  
// in below array 
$arr1 = array(5, 6, 7, 8, 9, 10, 1, 2, 3); 
$n = count($arr1); 
$key = 3; 
  
// Function calling 
echo "Index of the element is : " ,  
      pivotedBinarySearch($arr1, $n, $key); 
              
// This code is contributed by anuj_67. 
?> 

Output:

Index of the element is : 8

Time Complexity O(logn). Thanks to Ajay Mishra for initial solution.

Improved Solution:
We can search an element in one pass of Binary Search. The idea is to search

1) Find middle point mid = (l + h)/2
2) If key is present at middle point, return mid.
3) Else If arr[l..mid] is sorted
    a) If key to be searched lies in range from arr[l]
       to arr[mid], recur for arr[l..mid].
    b) Else recur for arr[mid+1..h]
4) Else (arr[mid+1..h] must be sorted)
    a) If key to be searched lies in range from arr[mid+1]
       to arr[h], recur for arr[mid+1..h].
    b) Else recur for arr[l..mid]

Below is the implementation of above idea :

C++

// Search an element in sorted and rotated 
// array using single pass of Binary Search 
#include <bits/stdc++.h> 
using namespace std; 
  
// Returns index of key in arr[l..h] if  
// key is present, otherwise returns -1 
int search(int arr[], int l, int h, int key) 
{ 
    if (l > h) return -1; 
  
    int mid = (l+h)/2; 
    if (arr[mid] == key) return mid; 
  
    /* If arr[l...mid] is sorted */
    if (arr[l] <= arr[mid]) 
    { 
        /* As this subarray is sorted, we can quickly 
        check if key lies in half or other half */
        if (key >= arr[l] && key <= arr[mid]) 
        return search(arr, l, mid-1, key); 
         /*If key not lies in first half subarray,  
           Divide other half  into two subarrays, 
           such that we can quickly check if key lies  
           in other half */
        return search(arr, mid+1, h, key); 
    } 
  
    /* If arr[l..mid] first subarray is not sorted, then arr[mid... h] 
    must be sorted subarray */
    if (key >= arr[mid] && key <= arr[h]) 
        return search(arr, mid+1, h, key); 
  
    return search(arr, l, mid-1, key); 
} 
  
// Driver program 
int main() 
{ 
    int arr[] = {4, 5, 6, 7, 8, 9, 1, 2, 3}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    int key = 6; 
    int i = search(arr, 0, n-1, key); 
  
    if (i != -1) 
    cout << "Index: " << i << endl; 
    else
    cout << "Key not found"; 
} 

Java

/* Java program to search an element in  
   sorted and rotated array using 
   single pass of Binary Search*/
   
class Main 
{ 
    // Returns index of key in arr[l..h]  
    // if key is present, otherwise returns -1 
    static int search(int arr[], int l, int h, int key) 
    { 
        if (l > h)  
            return -1; 
        
        int mid = (l+h)/2; 
        if (arr[mid] == key) 
            return mid; 
        
        /* If arr[l...mid] first subarray is sorted */
        if (arr[l] <= arr[mid]) 
        { 
            /* As this subarray is sorted, we  
               can quickly check if key lies in  
               half or other half */
            if (key >= arr[l] && key <= arr[mid]) 
               return search(arr, l, mid-1, key); 
            /*If key not lies in first half subarray,  
           Divide other half  into two subarrays, 
           such that we can quickly check if key lies  
           in other half */
            return search(arr, mid+1, h, key); 
        } 
        
        /* If arr[l..mid] first subarray is not sorted,  
           then arr[mid... h] must be sorted subarry*/
        if (key >= arr[mid] && key <= arr[h]) 
            return search(arr, mid+1, h, key); 
        
        return search(arr, l, mid-1, key); 
    } 
    
    //main function 
    public static void main(String args[]) 
    { 
        int arr[] = {4, 5, 6, 7, 8, 9, 1, 2, 3}; 
        int n = arr.length; 
        int key = 6; 
        int i = search(arr, 0, n-1, key); 
        if (i != -1)  
            System.out.println("Index: " + i); 
        else
            System.out.println("Key not found"); 
    } 
} 

Python3

# Search an element in sorted and rotated array using 
# single pass of Binary Search 
  
# Returns index of key in arr[l..h] if key is present, 
# otherwise returns -1 
def search (arr, l, h, key): 
    if l > h: 
        return -1
      
    mid = (l + h) // 2
    if arr[mid] == key: 
        return mid 
  
    # If arr[l...mid] is sorted  
    if arr[l] <= arr[mid]: 
  
        # As this subarray is sorted, we can quickly 
        # check if key lies in half or other half  
        if key >= arr[l] and key <= arr[mid]: 
            return search(arr, l, mid-1, key) 
        return search(arr, mid+1, h, key) 
  
    # If arr[l..mid] is not sorted, then arr[mid... r] 
    # must be sorted 
    if key >= arr[mid] and key <= arr[h]: 
        return search(a, mid+1, h, key) 
    return search(arr, l, mid-1, key) 
  
# Driver program 
arr = [4, 5, 6, 7, 8, 9, 1, 2, 3] 
key = 6
i = search(arr, 0, len(arr)-1, key) 
if i != -1: 
    print ("Index: %d"%i) 
else: 
    print ("Key not found") 
  
# This code is contributed by Shreyanshi Arun 

C#

/* C# program to search an element in  
sorted and rotated array using 
single pass of Binary Search*/
using System; 
  
class GFG { 
      
    // Returns index of key in arr[l..h]  
    // if key is present, otherwise 
    // returns -1 
    static int search(int []arr, int l, int h, 
                                       int key) 
    { 
        if (l > h)  
            return -1; 
      
        int mid = (l + h) / 2; 
          
        if (arr[mid] == key) 
            return mid; 
      
        /* If arr[l...mid] is sorted */
        if (arr[l] <= arr[mid]) 
        { 
              
            /* As this subarray is sorted, we  
            can quickly check if key lies in  
            half or other half */
            if (key >= arr[l] && key <= arr[mid]) 
            return search(arr, l, mid - 1, key); 
      
            return search(arr, mid + 1, h, key); 
        } 
      
        /* If arr[l..mid] is not sorted,  
        then arr[mid... r] must be sorted*/
        if (key >= arr[mid] && key <= arr[h]) 
            return search(arr, mid + 1, h, key); 
      
        return search(arr, l, mid - 1, key); 
    } 
  
    // main function 
    public static void Main() 
    { 
        int []arr = {4, 5, 6, 7, 8, 9, 1, 2, 3}; 
        int n = arr.Length; 
        int key = 6; 
        int i = search(arr, 0, n - 1, key); 
          
        if (i != -1)  
            Console.WriteLine("Index: " + i); 
        else
            Console.WriteLine("Key not found"); 
    } 
} 
  
// This code is contributed by anuj_67. 

PHP

<?php 
// Search an element in sorted and rotated 
// array using single pass of Binary Search 
  
// Returns index of key in arr[l..h] if  
// key is present, otherwise returns -1 
function search($arr, $l, $h, $key) 
{ 
    if ($l > $h) return -1; 
  
    $mid = ($l + $h) / 2; 
    if ($arr[$mid] == $key) 
        return $mid; 
  
    /* If arr[l...mid] is sorted */
    if ($arr[$l] <= $arr[$mid]) 
    { 
          
        /* As this subarray is  
           sorted, we can quickly 
           check if key lies in  
           half or other half */
        if ($key >= $arr[$l] &&  
            $key <= $arr[$mid]) 
                return search($arr, $l,  
                       $mid - 1, $key); 
  
        return search($arr, $mid + 1, 
                           $h, $key); 
    } 
  
    /* If arr[l..mid] is not  
       sorted, then arr[mid... r] 
       must be sorted*/
    if ($key >= $arr[$mid] &&  
          $key <= $arr[$h]) 
        return search($arr, $mid + 1,  
                            $h, $key); 
  
    return search($arr, $l,  
             $mid-1, $key); 
} 
  
    // Driver Code 
    $arr = array(4, 5, 6, 7, 8, 9, 1, 2, 3); 
    $n = sizeof($arr); 
    $key = 6; 
    $i = search($arr, 0, $n-1, $key); 
  
    if ($i != -1) 
        echo "Index: ", floor($i) ," \n"; 
    else
        echo "Key not found"; 
  
// This code is contributed by ajit 
?> 

Output:

Index: 2

Thanks to Gaurav Ahirwar for suggesting above solution.

How to handle duplicates?
It doesn’t look possible to search in O(Logn) time in all cases when duplicates are allowed. For example consider searching 0 in {2, 2, 2, 2, 2, 2, 2, 2, 0, 2} and {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}. It doesn’t look possible to decide whether to recur for left half or right half by doing constant number of comparisons at the middle.

Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem.

My Personal Notes

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

C

Java

Python3

C#

PHP

C++

Java

Python3

C#

PHP

Recommended Posts: