Java Program for Search an element in a sorted and rotated array

06 Apr, 2022
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};
         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:  
The idea is to find the pivot point, divide the array in two sub-arrays and perform 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 the above statement and binary search pivot can be found.After the pivot is found out divide the array in two sub-arrays.Now the individual sub – arrays are sorted so the element can be searched using Binary Search.
The idea is to find the pivot point, divide the array in two sub-arrays and perform 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 the above statement and binary search pivot can be found.
After the pivot is found out divide the array in two sub-arrays.
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:  
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));    }}
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:  
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 subarray*/        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");    }}
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. 
Search an element in a sorted and rotated array | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersSearch an element in a sorted and rotated array | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 15:16•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=uN5QUBHUQaM" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Similar Articles:  
Find the minimum element in a sorted and rotated array
Given a sorted and rotated array, find if there is a pair with a given sum.
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!
simmytarika5
Adobe
Amazon
BankBazaar
Binary Search
D-E-Shaw
FactSet
Flipkart
Hike
MakeMyTrip
Microsoft
Paytm
rotation
Samsung
SAP Labs
Snapdeal
Times Internet
Arrays
Java
Java Programs
Searching
Paytm
Flipkart
Amazon
Microsoft
Samsung
Snapdeal
D-E-Shaw
FactSet
Hike
MakeMyTrip
Adobe
BankBazaar
Times Internet
SAP Labs
Arrays
Searching
Java
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Window Sliding Technique
Search, insert and delete in an unsorted array
What is Data Structure: Types, Classifications and Applications
Chocolate Distribution Problem
Arrays.sort() in Java with examples
Split() String method in Java with examples
Reverse a string in Java
Object Oriented Programming (OOPs) Concept in Java
For-each loop in Java