Open In App

C++ Program for Search an element in a sorted and rotated array

Last Updated : 19 Sep, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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.
 

sortedPivotedArray

Example: 
 

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 the array are distinct.
Basic Solution: 
Approach: 
 

  1. The idea is to find the pivot point, divide the array in two sub-arrays and perform binary search.
  2. 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.
  3. Using the above statement and binary search pivot can be found.
  4. After the pivot is found out divide the array in two sub-arrays.
  5. Now the individual sub – arrays are sorted so the element can be searched using Binary Search.

Implementation: 
 

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;
}


Output: 
 

Index of the element is : 8

Complexity Analysis: 
 

  • Time Complexity: O(log n). 
    Binary Search requires log n comparisons to find the element. So time complexity is O(log n).
  • Space Complexity:O(1), No extra space is required.

Thanks to Ajay Mishra for initial solution.
Improved Solution: 
Approach: Instead of two or more pass of binary search the result can be found in one pass of binary search. The binary search needs to be modified to perform the search. The idea is to create a recursive function that takes l and r as range in input and the key.
 

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";
}


Output: 

Index: 2

Complexity Analysis: 
 

  • Time Complexity: O(log n). 
    Binary Search requires log n comparisons to find the element. So time complexity is O(log n).
  • Space Complexity: O(1). 
    As no extra space is required.

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 the left half or right half by doing a constant number of comparisons at the middle.
 

Similar Articles: 
 

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

Please refer complete article on Search an element in a sorted and rotated array for more details!



Similar Reads

Java Program for 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. Example: Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
9 min read
Python3 Program for 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. Example: Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
9 min read
C# Program for 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.  Example:   Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3
7 min read
Php Program for 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.  Example:   Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3
6 min read
Javascript Program for 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.  Example:   Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3
7 min read
C Program for 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.  Example:   Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3
4 min read
Search an element in a sorted and rotated array with duplicates
Given an array arr[] which is sorted and rotated, the task is to find an element in the rotated array (with duplicates) in O(log n) time. Note: Print the index where the key exists. In case of multiple answer print any of them Examples: Input: arr[] = {3, 3, 3, 1, 2, 3}, key = 3 Output: 0 arr[0] = 3 Input: arr[] = {3, 3, 3, 1, 2, 3}, key = 11 Outpu
14 min read
Search an element in a sorted and rotated Array
Given a sorted and rotated array arr[] of size N and a key, the task is to find the key in the array. Note: Find the element in O(logN) time and assume that all the elements are distinct. Example: Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3}, key = 3Output : Found at index 8 Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3}, key = 30Output : Not found I
28 min read
Circularly Sorted Array (Sorted and Rotated Array)
Circularly sorted arrays are arrays that are sorted in ascending or descending order and then rotated by a number of steps. Let us take an example to know more about circularly sorted arrays: Consider an array: arr[] = {23, 34, 45, 12, 17, 19}The elements here, {12, 17, 19, 23, 34, 45} are sorted 'In-order' but they are rotated to the left by 3 tim
7 min read
Check if an array is sorted and rotated using Binary Search
Pre-requisite: Check if an array is sorted and rotated using Linear SearchGiven an array arr[] of N distinct integers, the task is to check if this array is sorted when rotated counter-clockwise. A sorted array is not considered sorted and rotated, i.e., there should at least one rotation. Examples: Input: arr[] = { 3, 4, 5, 1, 2 } Output: true Exp
11 min read