Find the minimum element in a sorted and rotated array

A sorted array is rotated at some unknown point, find the minimum element in it.

Following solution assumes that all elements are distinct.

Examples:

Input: {5, 6, 1, 2, 3, 4}
Output: 1

Input: {1, 2, 3, 4}
Output: 1

Input: {2, 1}
Output: 1

A simple solution is to traverse the complete array and find minimum. This solution requires ?(n) time.
We can do it in O(Logn) using Binary Search. If we take a closer look at above examples, we can easily figure out following pattern:

• The minimum element is the only element whose previous is greater than it. If there is no previous element element, then there is no rotation (first element is minimum). We check this condition for middle element by comparing it with (mid-1)’th and (mid+1)’th elements.
• If minimum element is not at middle (neither mid nor mid + 1), then minimum element lies in either left half or right half.
1. If middle element is smaller than last element, then the minimum element lies in left half
2. Else minimum element lies in right half.

We strongly recommend you to try it yourself before seeing the following implementation.

C++

br>
 // C++ program to find minimum  // element in a sorted and rotated array  #include using namespace std;    int findMin(int arr[], int low, int high)  {      // This condition is needed to      // handle the case when array is not      // rotated at all      if (high < low) return arr;         // If there is only one element left      if (high == low) return arr[low];         // Find mid      int mid = low + (high - low)/2; /*(low + high)/2;*/        // Check if element (mid+1) is minimum element. Consider      // the cases like {3, 4, 5, 1, 2}      if (mid < high && arr[mid + 1] < arr[mid])      return arr[mid + 1];         // Check if mid itself is minimum element      if (mid > low && arr[mid] < arr[mid - 1])      return arr[mid];         // Decide whether we need to go to left half or right half      if (arr[high] > arr[mid])      return findMin(arr, low, mid - 1);      return findMin(arr, mid + 1, high);  }     // Driver program to test above functions  int main()  {      int arr1[] = {5, 6, 1, 2, 3, 4};      int n1 = sizeof(arr1)/sizeof(arr1);      cout << "The minimum element is " << findMin(arr1, 0, n1-1) << endl;         int arr2[] = {1, 2, 3, 4};      int n2 = sizeof(arr2)/sizeof(arr2);      cout << "The minimum element is " << findMin(arr2, 0, n2-1) << endl;         int arr3[] = {1};      int n3 = sizeof(arr3)/sizeof(arr3);      cout<<"The minimum element is "<

C

 // C program to find minimum element in a sorted and rotated array #include    int findMin(int arr[], int low, int high) {     // This condition is needed to handle the case when array is not     // rotated at all     if (high < low)  return arr;        // If there is only one element left     if (high == low) return arr[low];        // Find mid     int mid = low + (high - low)/2; /*(low + high)/2;*/        // Check if element (mid+1) is minimum element. Consider     // the cases like {3, 4, 5, 1, 2}     if (mid < high && arr[mid+1] < arr[mid])        return arr[mid+1];        // Check if mid itself is minimum element     if (mid > low && arr[mid] < arr[mid - 1])        return arr[mid];        // Decide whether we need to go to left half or right half     if (arr[high] > arr[mid])        return findMin(arr, low, mid-1);     return findMin(arr, mid+1, high); }    // Driver program to test above functions int main() {     int arr1[] =  {5, 6, 1, 2, 3, 4};     int n1 = sizeof(arr1)/sizeof(arr1);     printf("The minimum element is %d ", findMin(arr1, 0, n1-1));        int arr2[] =  {1, 2, 3, 4};     int n2 = sizeof(arr2)/sizeof(arr2);     printf("The minimum element is %d ", findMin(arr2, 0, n2-1));        int arr3[] =  {1};     int n3 = sizeof(arr3)/sizeof(arr3);     printf("The minimum element is %d ", findMin(arr3, 0, n3-1));        int arr4[] =  {1, 2};     int n4 = sizeof(arr4)/sizeof(arr4);     printf("The minimum element is %d ", findMin(arr4, 0, n4-1));        int arr5[] =  {2, 1};     int n5 = sizeof(arr5)/sizeof(arr5);     printf("The minimum element is %d ", findMin(arr5, 0, n5-1));        int arr6[] =  {5, 6, 7, 1, 2, 3, 4};     int n6 = sizeof(arr6)/sizeof(arr6);     printf("The minimum element is %d ", findMin(arr6, 0, n6-1));        int arr7[] =  {1, 2, 3, 4, 5, 6, 7};     int n7 = sizeof(arr7)/sizeof(arr7);     printf("The minimum element is %d ", findMin(arr7, 0, n7-1));        int arr8[] =  {2, 3, 4, 5, 6, 7, 8, 1};     int n8 = sizeof(arr8)/sizeof(arr8);     printf("The minimum element is %d ", findMin(arr8, 0, n8-1));        int arr9[] =  {3, 4, 5, 1, 2};     int n9 = sizeof(arr9)/sizeof(arr9);     printf("The minimum element is %d ", findMin(arr9, 0, n9-1));        return 0; }

Java

 // Java program to find minimum element in a sorted and rotated array import java.util.*; import java.lang.*; import java.io.*;    class Minimum {     static int findMin(int arr[], int low, int high)     {         // This condition is needed to handle the case when array         // is not rotated at all         if (high < low)  return arr;            // If there is only one element left         if (high == low) return arr[low];            // Find mid         int mid = low + (high - low)/2; /*(low + high)/2;*/            // Check if element (mid+1) is minimum element. Consider         // the cases like {3, 4, 5, 1, 2}         if (mid < high && arr[mid+1] < arr[mid])             return arr[mid+1];            // Check if mid itself is minimum element         if (mid > low && arr[mid] < arr[mid - 1])             return arr[mid];            // Decide whether we need to go to left half or right half         if (arr[high] > arr[mid])             return findMin(arr, low, mid-1);         return findMin(arr, mid+1, high);     }        // Driver Program     public static void main (String[] args)     {         int arr1[] =  {5, 6, 1, 2, 3, 4};         int n1 = arr1.length;         System.out.println("The minimum element is "+ findMin(arr1, 0, n1-1));            int arr2[] =  {1, 2, 3, 4};         int n2 = arr2.length;         System.out.println("The minimum element is "+ findMin(arr2, 0, n2-1));            int arr3[] =  {1};         int n3 = arr3.length;         System.out.println("The minimum element is "+ findMin(arr3, 0, n3-1));            int arr4[] =  {1, 2};         int n4 = arr4.length;         System.out.println("The minimum element is "+ findMin(arr4, 0, n4-1));            int arr5[] =  {2, 1};         int n5 = arr5.length;         System.out.println("The minimum element is "+ findMin(arr5, 0, n5-1));            int arr6[] =  {5, 6, 7, 1, 2, 3, 4};         int n6 = arr6.length;         System.out.println("The minimum element is "+ findMin(arr6, 0, n6-1));            int arr7[] =  {1, 2, 3, 4, 5, 6, 7};         int n7 = arr7.length;         System.out.println("The minimum element is "+ findMin(arr7, 0, n7-1));            int arr8[] =  {2, 3, 4, 5, 6, 7, 8, 1};         int n8 = arr8.length;         System.out.println("The minimum element is "+ findMin(arr8, 0, n8-1));            int arr9[] =  {3, 4, 5, 1, 2};         int n9 = arr9.length;         System.out.println("The minimum element is "+ findMin(arr9, 0, n9-1));     } }

Python

 # Python program to find minimum element # in a sorted and rotated array    def findMin(arr, low, high):     # This condition is needed to handle the case when array is not     # rotated at all     if high < low:         return arr        # If there is only one element left     if high == low:         return arr[low]        # Find mid     mid = int((low + high)/2)        # Check if element (mid+1) is minimum element. Consider     # the cases like [3, 4, 5, 1, 2]     if mid < high and arr[mid+1] < arr[mid]:         return arr[mid+1]        # Check if mid itself is minimum element     if mid > low and arr[mid] < arr[mid - 1]:         return arr[mid]        # Decide whether we need to go to left half or right half     if arr[high] > arr[mid]:         return findMin(arr, low, mid-1)     return findMin(arr, mid+1, high)    # Driver program to test above functions arr1 = [5, 6, 1, 2, 3, 4] n1 = len(arr1) print("The minimum element is " + str(findMin(arr1, 0, n1-1)))    arr2 = [1, 2, 3, 4] n2 = len(arr2) print("The minimum element is " + str(findMin(arr2, 0, n2-1)))    arr3 =  n3 = len(arr3) print("The minimum element is " + str(findMin(arr3, 0, n3-1)))    arr4 = [1, 2] n4 = len(arr4) print("The minimum element is " + str(findMin(arr4, 0, n4-1)))    arr5 = [2, 1] n5 = len(arr5) print("The minimum element is " + str(findMin(arr5, 0, n5-1)))    arr6 = [5, 6, 7, 1, 2, 3, 4] n6 = len(arr6) print("The minimum element is " + str(findMin(arr6, 0, n6-1)))    arr7 = [1, 2, 3, 4, 5, 6, 7] n7 = len(arr7) print("The minimum element is " + str(findMin(arr7, 0, n7-1)))    arr8 = [2, 3, 4, 5, 6, 7, 8, 1] n8 = len(arr8) print("The minimum element is " + str(findMin(arr8, 0, n8-1)))    arr9 = [3, 4, 5, 1, 2] n9 = len(arr9) print("The minimum element is " + str(findMin(arr9, 0, n9-1)))    # This code is contributed by Pratik Chhajer

C#

 // C# program to find minimum element  // in a sorted and rotated array using System;    class Minimum {        static int findMin(int[] arr, int low, int high)     {         // This condition is needed to handle          // the case when array         // is not rotated at all         if (high < low)             return arr;            // If there is only one element left         if (high == low)             return arr[low];            // Find mid         // (low + high)/2         int mid = low + (high - low) / 2;             // Check if element (mid+1) is minimum element. Consider         // the cases like {3, 4, 5, 1, 2}         if (mid < high && arr[mid + 1] < arr[mid])             return arr[mid + 1];            // Check if mid itself is minimum element         if (mid > low && arr[mid] < arr[mid - 1])             return arr[mid];            // Decide whether we need to go to         // left half or right half         if (arr[high] > arr[mid])             return findMin(arr, low, mid - 1);         return findMin(arr, mid + 1, high);     }        // Driver Program     public static void Main()     {         int[] arr1 = { 5, 6, 1, 2, 3, 4 };         int n1 = arr1.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr1, 0, n1 - 1));            int[] arr2 = { 1, 2, 3, 4 };         int n2 = arr2.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr2, 0, n2 - 1));            int[] arr3 = { 1 };         int n3 = arr3.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr3, 0, n3 - 1));            int[] arr4 = { 1, 2 };         int n4 = arr4.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr4, 0, n4 - 1));            int[] arr5 = { 2, 1 };         int n5 = arr5.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr5, 0, n5 - 1));            int[] arr6 = { 5, 6, 7, 1, 2, 3, 4 };         int n6 = arr6.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr6, 0, n1 - 1));            int[] arr7 = { 1, 2, 3, 4, 5, 6, 7 };         int n7 = arr7.Length;         Console.WriteLine("The minimum element is " +                            findMin(arr7, 0, n7 - 1));            int[] arr8 = { 2, 3, 4, 5, 6, 7, 8, 1 };         int n8 = arr8.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr8, 0, n8 - 1));            int[] arr9 = { 3, 4, 5, 1, 2 };         int n9 = arr9.Length;         Console.WriteLine("The minimum element is " +                             findMin(arr9, 0, n9 - 1));     } }    // This code is contributed by vt_m.

PHP

 \$low &&          \$arr[\$mid] < \$arr[\$mid - 1])     return \$arr[\$mid];        // Decide whether we need      // to go to left half or      // right half     if (\$arr[\$high] > \$arr[\$mid])     return findMin(\$arr, \$low,                     \$mid - 1);     return findMin(\$arr,                     \$mid + 1, \$high); }    // Driver Code \$arr1 = array(5, 6, 1, 2, 3, 4); \$n1 = sizeof(\$arr1); echo "The minimum element is " .      findMin(\$arr1, 0, \$n1 - 1) . " ";    \$arr2 = array(1, 2, 3, 4); \$n2 = sizeof(\$arr2); echo "The minimum element is " .      findMin(\$arr2, 0, \$n2 - 1) . " ";    \$arr3 = array(1); \$n3 = sizeof(\$arr3); echo "The minimum element is " .      findMin(\$arr3, 0, \$n3 - 1) . " ";    \$arr4 = array(1, 2); \$n4 = sizeof(\$arr4); echo "The minimum element is " .      findMin(\$arr4, 0, \$n4 - 1) . " ";    \$arr5 = array(2, 1); \$n5 = sizeof(\$arr5); echo "The minimum element is " .      findMin(\$arr5, 0, \$n5 - 1) . " ";    \$arr6 = array(5, 6, 7, 1, 2, 3, 4); \$n6 = sizeof(\$arr6); echo "The minimum element is " .      findMin(\$arr6, 0, \$n6 - 1) . " ";    \$arr7 = array(1, 2, 3, 4, 5, 6, 7); \$n7 = sizeof(\$arr7); echo "The minimum element is " .      findMin(\$arr7, 0, \$n7 - 1) . " ";    \$arr8 = array(2, 3, 4, 5, 6, 7, 8, 1); \$n8 = sizeof(\$arr8); echo "The minimum element is " .      findMin(\$arr8, 0, \$n8 - 1) . " ";    \$arr9 = array(3, 4, 5, 1, 2); \$n9 = sizeof(\$arr9); echo "The minimum element is " .     findMin(\$arr9, 0, \$n9 - 1) . " ";    // This code is contributed by ChitraNayal ?>

Output:

The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1

How to handle duplicates?
It turned out that duplicates can’t be handled in O(Logn) time in all cases. Thanks to Amit Jain for inputs. The special cases that cause problems are like {2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 2} and {2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2}. It doesn’t look possible to go to left half or right half by doing constant number of comparisons at the middle. So the problem with repetition can be solved in O(n) worst case.