Open In App

Search in a Sorted and Rotated Array

Last Updated : 07 Dec, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a sorted and rotated array arr[] of n distinct elements, the task is to find the index of given key in the array. If the key is not present in the array, return -1.

Examples:  

Input: arr[] = [5, 6, 7, 8, 9, 10, 1, 2, 3], key = 3
Output: 8
Explanation: 3 is present at index 8 in arr[].

Input: arr[] = [3, 5, 1, 2], key = 6
Output: -1
Explanation: 6 is not present in arr[].

Input: arr[] = [33, 42, 72, 99], key = 42
Output: 1
Explanation: 42 is found at index 1.

Table of Content

[Naive Approach] Using Linear Search - O(n) Time and O(1) Space

A simple approach is to iterate through the array and check for each element, if it matches the target then return the index, otherwise return -1. To know more about the implementation, please refer Introduction to Linear Search Algorithm.

[Expected Approach 1] Using Binary Search Twice - O(log n) Time and O(1) Space

The idea is to use binary search twice:

1. Find the pivot point (or index of the min element) : For example, the min in [4, 5, 6, 7, 0, 1, 2] is 0 at index 4. Refer Minimum in a Sorted and Rotated Array to find the index of the minimum element.

2. Binary Search in the Sorted Subarray: Once we find the pivot, we can easily divide the given array into two sorted subarrays using the index of the minimum element. For example, the index of the minimum element in [4, 5, 6, 7, 0, 1, 2] is 4, so the two sorted subarrays are [4, 5, 6, 7] and [1, 2]. Following are the cases that arise

  • If the minimum element = key, then return index of the minimum element.
  • If index of minimum element is 0, then the whole array is sorted, we call binary search for the whole array.
  • If index of minimum element > 0, then instead of calling binary search for both sides, we can save one binary search by comparing the given key with the first element on left side. If key is greater than equal to the first element, we do binary search in the first subarray else in the second.
C++ 
// C++ program to search an element in sorted and rotated 
// array using binary search twice

#include <iostream>
#include <vector>
using namespace std;

// An iterative binary search function
int binarySearch(vector<int> &arr, int lo, int hi, int x) {
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        if (arr[mid] == x) return mid;
        if (arr[mid] < x) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

// Function to return pivot (index of the smallest element)
int findPivot(vector<int> &arr, int lo, int hi) {
    while (lo < hi) {
      
        // The current subarray is already sorted,
        // the minimum is at the low index
        if (arr[lo] <= arr[hi])        
            return lo;
        
        int mid = (lo + hi) / 2;

        // The right half is not sorted. So
        // the minimum element must be in the
        // right half.
        if (arr[mid] > arr[hi])
            lo = mid + 1;
      
        // The right half is sorted. Note that in
        // this case, we do not change high to mid - 1
        // but keep it to mid. The mid element
        // itself can be the smallest
        else
            hi = mid;
    }

    return lo;
}

// Searches an element key in a pivoted
// sorted array arr of size n
int search(vector<int> &arr, int key) {
  	int n = arr.size();
    int pivot = findPivot(arr, 0, n - 1);

    // 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 the minimum element is present at index
    // 0, then the whole array is sorted
    if (pivot == 0)
        return binarySearch(arr, 0, n - 1, key);

    if (arr[0] <= key)
        return binarySearch(arr, 0, pivot - 1, key);
    return binarySearch(arr, pivot + 1, n - 1, key);
}

int main() {
    vector<int> arr = {5, 6, 7, 8, 9, 10, 1, 2, 3};
    int key = 3;
    cout << search(arr, key);
    return 0;
}
C 
// C program to search an element in sorted and rotated 
// array using binary search twice

#include <stdio.h>

// An iterative binary search function
int binarySearch(int arr[], int lo, int hi, int x) {
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        if (arr[mid] == x) return mid;
        if (arr[mid] < x) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

// Function to return pivot (index of the smallest element)
int findPivot(int arr[], int lo, int hi) {
    while (lo < hi) {
      
        // The current subarray is already sorted,
        // the minimum is at the low index
        if (arr[lo] <= arr[hi])        
            return lo;
        
        int mid = (lo + hi) / 2;

        // The right half is not sorted. So
        // the minimum element must be in the
        // right half.
        if (arr[mid] > arr[hi])
            lo = mid + 1;
      
        // The right half is sorted. Note that in
        // this case, we do not change high to mid - 1
        // but keep it to mid. The mid element
        // itself can be the smallest
        else
            hi = mid;
    }

    return lo;
}

// Searches an element key in a pivoted
// sorted array arr of size n
int search(int arr[], int n, int key) {
    int pivot = findPivot(arr, 0, n - 1);

    // 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 the minimum element is present at index
    // 0, then the whole array is sorted
    if (pivot == 0)
        return binarySearch(arr, 0, n - 1, key);

    if (arr[0] <= key)
        return binarySearch(arr, 0, pivot - 1, key);
    return binarySearch(arr, pivot + 1, n - 1, key);
}

int main() {
    int arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 3;
    printf("%d\n", search(arr, n, key));
    return 0;
}
Java 
// Java program to search an element in sorted and rotated 
// array using binary search twice

import java.util.*;
class GfG {
  
    // An iterative binary search function
    static int binarySearch(int[] arr, int lo, int hi, int x) {
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (arr[mid] == x) return mid;
            if (arr[mid] < x) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }

    // Function to return pivot (index of the smallest element)
    static int findPivot(int[] arr, int lo, int hi) {
        while (lo < hi) {
          
            // The current subarray is already sorted,
            // the minimum is at the low index
            if (arr[lo] <= arr[hi])
                return lo;

            int mid = (lo + hi) / 2;

            // The right half is not sorted. So
            // the minimum element must be in the
            // right half
            if (arr[mid] > arr[hi])
                lo = mid + 1;

            // The right half is sorted. Note that in
            // this case, we do not change high to mid - 1
            // but keep it to mid. The mid element
            // itself can be the smallest
            else
                hi = mid;
        }

        return lo;
    }

    // Searches an element key in a pivoted
    // sorted array arr of size n
    static int search(int[] arr, int key) {
        int n = arr.length;
        int pivot = findPivot(arr, 0, n - 1);

        // 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 the minimum element is present at index
        // 0, then the whole array is sorted
        if (pivot == 0)
            return binarySearch(arr, 0, n - 1, key);

        if (arr[0] <= key)
            return binarySearch(arr, 0, pivot - 1, key);
        return binarySearch(arr, pivot + 1, n - 1, key);
    }

    public static void main(String[] args) {
        int[] arr = {5, 6, 7, 8, 9, 10, 1, 2, 3};
        int key = 3;
        System.out.println(search(arr, key));
    }
}
Python 
# Python program to search an element in sorted and rotated 
# array using binary search twice

# An iterative binary search function
def binarySearch(arr, lo, hi, x):
    while lo <= hi:
        mid = lo + (hi - lo) // 2
        if arr[mid] == x:
            return mid
        if arr[mid] < x:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

# Function to return pivot (index of the smallest element)
def findPivot(arr, lo, hi):
    while lo < hi:

        # The current subarray is already sorted,
        # the minimum is at the low index
        if arr[lo] <= arr[hi]:
            return lo

        mid = (lo + hi) // 2

        # The right half is not sorted. So
        # the minimum element must be in the
        # right half.
        if arr[mid] > arr[hi]:
            lo = mid + 1

        # The right half is sorted. Note that in
        # this case, we do not change high to mid - 1
        # but keep it to mid. The mid element
        # itself can be the smallest
        else:
            hi = mid

    return lo

# Searches an element key in a pivoted
# sorted array arr of size n
def search(arr, key):
    n = len(arr)
    pivot = findPivot(arr, 0, n - 1)

    # 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 the minimum element is present at index
    # 0, then the whole array is sorted
    if pivot == 0:
        return binarySearch(arr, 0, n - 1, key)

    if arr[0] <= key:
        return binarySearch(arr, 0, pivot - 1, key)
    return binarySearch(arr, pivot + 1, n - 1, key)

if __name__ == "__main__":
    arr = [5, 6, 7, 8, 9, 10, 1, 2, 3]
    key = 3
    print(search(arr, key))
C# 
// C# program to search an element in sorted and rotated 
// array using  binary search twice

using System;
class GfG {

    // An iterative binary search function
    static int binarySearch(int[] arr, int lo, int hi, int x) {
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (arr[mid] == x) return mid;
            if (arr[mid] < x) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }

    // Function to return pivot (index of the smallest element)
    static int findPivot(int[] arr, int lo, int hi) {
        while (lo < hi) {

            // The current subarray is already sorted,
            // the minimum is at the low index
            if (arr[lo] <= arr[hi])
                return lo;

            int mid = (lo + hi) / 2;

            // The right half is not sorted. So
            // the minimum element must be in the
            // right half.
            if (arr[mid] > arr[hi])
                lo = mid + 1;

            // The right half is sorted. Note that in
            // this case, we do not change high to mid - 1
            // but keep it to mid. The mid element
            // itself can be the smallest
            else
                hi = mid;
        }

        return lo;
    }

    // Searches an element key in a pivoted
    // sorted array arr of size n
    static int search(int[] arr, int key) {
        int n = arr.Length;
        int pivot = findPivot(arr, 0, n - 1);

        // 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 the minimum element is present at index
        // 0, then the whole array is sorted
        if (pivot == 0)
            return binarySearch(arr, 0, n - 1, key);

        if (arr[0] <= key)
            return binarySearch(arr, 0, pivot - 1, key);
        return binarySearch(arr, pivot + 1, n - 1, key);
    }

    static void Main(string[] args) {
        int[] arr = { 5, 6, 7, 8, 9, 10, 1, 2, 3 };
        int key = 3;
        Console.WriteLine(search(arr, key));
    }
}
JavaScript 
// JavaScript program to search an element in sorted and rotated 
// array using  binary search twice

// An iterative binary search function
function binarySearch(arr, lo, hi, x) {
    while (lo <= hi) {
        let mid = lo + Math.floor((hi - lo) / 2);
        if (arr[mid] === x) return mid;
        if (arr[mid] < x) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

// Function to return pivot (index of the smallest element)
function findPivot(arr, lo, hi) {
    while (lo < hi) {

        // The current subarray is already sorted,
        // the minimum is at the low index
        if (arr[lo] <= arr[hi])
            return lo;

        let mid = Math.floor((lo + hi) / 2);

        // The right half is not sorted. So
        // the minimum element must be in the
        // right half.
        if (arr[mid] > arr[hi])
            lo = mid + 1;

        // The right half is sorted. Note that in
        // this case, we do not change high to mid - 1
        // but keep it to mid. The mid element
        // itself can be the smallest
        else
            hi = mid;
    }

    return lo;
}

// Searches an element key in a pivoted
// sorted array arr of size n
function search(arr, key) {
    let n = arr.length;
    let pivot = findPivot(arr, 0, n - 1);

    // 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 the minimum element is present at index
    // 0, then the whole array is sorted
    if (pivot === 0)
        return binarySearch(arr, 0, n - 1, key);

    if (arr[0] <= key)
        return binarySearch(arr, 0, pivot - 1, key);
    return binarySearch(arr, pivot + 1, n - 1, key);
}

// Driver code
let arr = [5, 6, 7, 8, 9, 10, 1, 2, 3];
let key = 3;
console.log(search(arr, key));

Output
8

[Expected Approach 2] Using Single Binary Search - O(log n) Time and O(1) Space

The idea is based on the fact that in a sorted and rotated array, if we go to mid, then either the left half would be sorted or the right half (both can also be sorted). For example, arr[] = [5, 6, 0, 1, 2, 3, 4], mid = 3 and we can see that the subarray from mid + 1 to high is sorted. And in [5, 6, 7, 8, 9, 3, 4], we can see that the subarray from low to mid-1 is sorted. We can check which half is sorted by comparing arr[low] and arr[mid] (We could also compare arr[high] and arr[mid]).

  • Find the mid point. If key is same as the mid, return the mid.
  • Find which half is sorted. If the key lies in the sorted half, move to that half. Otherwise move to the other half.

Note that once we find which half is sorted, we can easily check if the key lies here by checking if key lies in the range from smallest to largest in this half.


C++ 
// C++ program to search an element in sorted and rotated 
// array using binary search

#include <iostream>
#include <vector>
using namespace std;

int search(vector<int>& arr, int key) {
  
    // Initialize two pointers, lo and hi, at the start
    // and end of the array
    int lo = 0, hi = arr.size() - 1;

    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;

        // If key found, return the index
        if (arr[mid] == key)
            return mid;

        // If Left half is sorted
        if (arr[mid] >= arr[lo]) {
          
            // If the key lies within this sorted half,
            // move the hi pointer to mid - 1
            if (key >= arr[lo] && key < arr[mid])
                hi = mid - 1;
          
            // Otherwise, move the lo pointer to mid + 1
            else
                lo = mid + 1;
        }
      
        // If Right half is sorted
        else {
          
            // If the key lies within this sorted half,
            // move the lo pointer to mid + 1
            if (key > arr[mid] && key <= arr[hi])
                lo = mid + 1;
          
            // Otherwise, move the hi pointer to mid - 1
            else
                hi = mid - 1;
        }
    }
	
  	// Key not found
    return -1; 
}

int main() {
    vector<int> arr1 = {5, 6, 7, 8, 9, 10, 1, 2, 3};
    int key1 = 3;
    cout << search(arr1, key1) << endl;

    return 0;
}
C 
// C program to search an element in sorted and rotated 
// array using binary search

#include <stdio.h>
int search(int arr[], int n, int key) {
  
    // Initialize two pointers, lo and hi, at the start
    // and end of the array
    int lo = 0, hi = n - 1;

    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;

        // If key found, return the index
        if (arr[mid] == key)
            return mid;

        // If Left half is sorted
        if (arr[mid] >= arr[lo]) {
          
            // If the key lies within this sorted half,
            // move the hi pointer to mid - 1
            if (key >= arr[lo] && key < arr[mid])
                hi = mid - 1;
          
            // Otherwise, move the lo pointer to mid + 1
            else
                lo = mid + 1;
        }
      
        // If Right half is sorted
        else {
          
            // If the key lies within this sorted half,
            // move the lo pointer to mid + 1
            if (key > arr[mid] && key <= arr[hi])
                lo = mid + 1;
          
            // Otherwise, move the hi pointer to mid - 1
            else
                hi = mid - 1;
        }
    }
	
  	// Key not found
    return -1; 
}

int main() {
    int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int key1 = 3;
    printf("%d\n", search(arr1, n1, key1));

    return 0;
}
Java 
// Java program to search an element in sorted and rotated 
// array using binary search

import java.util.*;
class GfG {
  
    static int search(int[] arr, int key) {
      
        // Initialize two pointers, lo and hi, at the start
        // and end of the array
        int lo = 0, hi = arr.length - 1;

        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;

            // If key found, return the index
            if (arr[mid] == key)
                return mid;

            // If Left half is sorted
            if (arr[mid] >= arr[lo]) {
              
                // If the key lies within this sorted half,
                // move the hi pointer to mid - 1
                if (key >= arr[lo] && key < arr[mid])
                    hi = mid - 1;
              
                // Otherwise, move the lo pointer to mid + 1
                else
                    lo = mid + 1;
            }
          
            // If Right half is sorted
            else {
              
                // If the key lies within this sorted half,
                // move the lo pointer to mid + 1
                if (key > arr[mid] && key <= arr[hi])
                    lo = mid + 1;
              
                // Otherwise, move the hi pointer to mid - 1
                else
                    hi = mid - 1;
            }
        }
      
        // Key not found
        return -1; 
    }

    public static void main(String[] args) {
        int[] arr1 = {5, 6, 7, 8, 9, 10, 1, 2, 3};
        int key1 = 3;
        System.out.println(search(arr1, key1));
    }
}
Python 
# Python program to search an element in sorted and rotated 
# array using binary search

def search(arr, key):
  
    # Initialize two pointers, lo and hi, at the start
    # and end of the array
    lo = 0
    hi = len(arr) - 1

    while lo <= hi:
        mid = lo + (hi - lo) // 2

        # If key found, return the index
        if arr[mid] == key:
            return mid

        # If Left half is sorted
        if arr[mid] >= arr[lo]:
          
            # If the key lies within this sorted half,
            # move the hi pointer to mid - 1
            if key >= arr[lo] and key < arr[mid]:
                hi = mid - 1
              
            # Otherwise, move the lo pointer to mid + 1
            else:
                lo = mid + 1
          
        # If Right half is sorted
        else:
          
            # If the key lies within this sorted half,
            # move the lo pointer to mid + 1
            if key > arr[mid] and key <= arr[hi]:
                lo = mid + 1
              
            # Otherwise, move the hi pointer to mid - 1
            else:
                hi = mid - 1

    # Key not found
    return -1

if __name__ == "__main__":
    arr1 = [5, 6, 7, 8, 9, 10, 1, 2, 3]
    key1 = 3
    print(search(arr1, key1))
C# 
// C# program to search an element in sorted and rotated 
// array using binary search

using System;
class GfG {
  
    static int search(int[] arr, int key) {
      
        // Initialize two pointers, lo and hi, at the start
        // and end of the array
        int lo = 0, hi = arr.Length - 1;

        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;

            // If key found, return the index
            if (arr[mid] == key)
                return mid;

            // If Left half is sorted
            if (arr[mid] >= arr[lo]) {
              
                // If the key lies within this sorted half,
                // move the hi pointer to mid - 1
                if (key >= arr[lo] && key < arr[mid])
                    hi = mid - 1;
              
                // Otherwise, move the lo pointer to mid + 1
                else
                    lo = mid + 1;
            }
          
            // If Right half is sorted
            else {
              
                // If the key lies within this sorted half,
                // move the lo pointer to mid + 1
                if (key > arr[mid] && key <= arr[hi])
                    lo = mid + 1;
              
                // Otherwise, move the hi pointer to mid - 1
                else
                    hi = mid - 1;
            }
        }

        // Key not found
        return -1; 
    }

    static void Main(string[] args) {
        int[] arr1 = { 5, 6, 7, 8, 9, 10, 1, 2, 3 };
        int key1 = 3;
        Console.WriteLine(search(arr1, key1));
    }
}
JavaScript 
// JavaScript program to search an element in sorted and rotated 
// array using binary search

function search(arr, key) {
  
    // Initialize two pointers, lo and hi, at the start
    // and end of the array
    let lo = 0, hi = arr.length - 1;

    while (lo <= hi) {
        let mid = lo + Math.floor((hi - lo) / 2);

        // If key found, return the index
        if (arr[mid] === key)
            return mid;

        // If Left half is sorted
        if (arr[mid] >= arr[lo]) {
          
            // If the key lies within this sorted half,
            // move the hi pointer to mid - 1
            if (key >= arr[lo] && key < arr[mid])
                hi = mid - 1;
          
            // Otherwise, move the lo pointer to mid + 1
            else
                lo = mid + 1;
        }
      
        // If Right half is sorted
        else {
          
            // If the key lies within this sorted half,
            // move the lo pointer to mid + 1
            if (key > arr[mid] && key <= arr[hi])
                lo = mid + 1;
          
            // Otherwise, move the hi pointer to mid - 1
            else
                hi = mid - 1;
        }
    }

    // Key not found
    return -1; 
}

// Driver code
let arr1 = [5, 6, 7, 8, 9, 10, 1, 2, 3];
let key1 = 3;
console.log(search(arr1, key1));

Output
8



Next Article
Minimum in a Sorted and Rotated Array
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox