# 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
```

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

br>
 `/* C++ Program to search an element ` `   ``in a sorted and pivoted array*/` `#include ` `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 <= 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); ` `  ``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 ` ` `  `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 <= 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); ` `   ``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 <= 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

 ` ``\$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`` <= ``\$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 ` `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); ` `    ``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

 ` ``\$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``) ,````" "````; ` `    ``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.

This article is attributed to GeeksforGeeks.org

code

load comments