查找排序和旋转数组中的最小元素

已排序数组在某个未知点旋转，找到其中的最小元素。
以下解决方案假定所有元素都是不同的。

例子：

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

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

Input: {2, 1}
Output: 1

一个简单的解决方案是遍历整个数组并找到最小值。该解决方案需要 O(n) 时间。
我们可以使用二分搜索在 O(Logn) 中完成。如果我们仔细看看上面的例子，我们可以很容易地找出以下模式：

• 最小元素是前一个大于它的唯一元素。如果没有前一个元素，则没有旋转(第一个元素是最小的)。我们通过将中间元素与 (mid-1)’th 和 (mid+1)’th 元素进行比较来检查中间元素的这个条件。
• 如果最小元素不在中间(既不是 mid 也不是 mid + 1)，则最小元素位于左半边或右半边。
  1. 如果中间元素小于最后一个元素，则最小元素位于左半部分
  2. 否则最小元素位于右半部分。

我们强烈建议您在看到以下实现之前自己尝试一下。

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[0];
 
    // 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[0]);
    printf("The minimum element is %d\n", findMin(arr1, 0, n1-1));
 
    int arr2[] =  {1, 2, 3, 4};
    int n2 = sizeof(arr2)/sizeof(arr2[0]);
    printf("The minimum element is %d\n", findMin(arr2, 0, n2-1));
 
    int arr3[] =  {1};
    int n3 = sizeof(arr3)/sizeof(arr3[0]);
    printf("The minimum element is %d\n", findMin(arr3, 0, n3-1));
 
    int arr4[] =  {1, 2};
    int n4 = sizeof(arr4)/sizeof(arr4[0]);
    printf("The minimum element is %d\n", findMin(arr4, 0, n4-1));
 
    int arr5[] =  {2, 1};
    int n5 = sizeof(arr5)/sizeof(arr5[0]);
    printf("The minimum element is %d\n", findMin(arr5, 0, n5-1));
 
    int arr6[] =  {5, 6, 7, 1, 2, 3, 4};
    int n6 = sizeof(arr6)/sizeof(arr6[0]);
    printf("The minimum element is %d\n", findMin(arr6, 0, n6-1));
 
    int arr7[] =  {1, 2, 3, 4, 5, 6, 7};
    int n7 = sizeof(arr7)/sizeof(arr7[0]);
    printf("The minimum element is %d\n", findMin(arr7, 0, n7-1));
 
    int arr8[] =  {2, 3, 4, 5, 6, 7, 8, 1};
    int n8 = sizeof(arr8)/sizeof(arr8[0]);
    printf("The minimum element is %d\n", findMin(arr8, 0, n8-1));
 
    int arr9[] =  {3, 4, 5, 1, 2};
    int n9 = sizeof(arr9)/sizeof(arr9[0]);
    printf("The minimum element is %d\n", findMin(arr9, 0, n9-1));
 
    return 0;
}

C++

// 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[0];
 
    // 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[0]);
    cout << "The minimum element is " << findMin(arr1, 0, n1-1) << endl;
 
    int arr2[] = {1, 2, 3, 4};
    int n2 = sizeof(arr2)/sizeof(arr2[0]);
    cout << "The minimum element is " << findMin(arr2, 0, n2-1) << endl;
 
    int arr3[] = {1};
    int n3 = sizeof(arr3)/sizeof(arr3[0]);
    cout<<"The minimum element is "<

---

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[0];
 
        // 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[0]
 
    # 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 = [1]
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[0];
 
        // 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) . "\n";
 
$arr2 = array(1, 2, 3, 4);
$n2 = sizeof($arr2);
echo "The minimum element is " .
    findMin($arr2, 0, $n2 - 1) . "\n";
 
$arr3 = array(1);
$n3 = sizeof($arr3);
echo "The minimum element is " .
    findMin($arr3, 0, $n3 - 1) . "\n";
 
$arr4 = array(1, 2);
$n4 = sizeof($arr4);
echo "The minimum element is " .
    findMin($arr4, 0, $n4 - 1) . "\n";
 
$arr5 = array(2, 1);
$n5 = sizeof($arr5);
echo "The minimum element is " .
    findMin($arr5, 0, $n5 - 1) . "\n";
 
$arr6 = array(5, 6, 7, 1, 2, 3, 4);
$n6 = sizeof($arr6);
echo "The minimum element is " .
    findMin($arr6, 0, $n6 - 1) . "\n";
 
$arr7 = array(1, 2, 3, 4, 5, 6, 7);
$n7 = sizeof($arr7);
echo "The minimum element is " .
    findMin($arr7, 0, $n7 - 1) . "\n";
 
$arr8 = array(2, 3, 4, 5, 6, 7, 8, 1);
$n8 = sizeof($arr8);
echo "The minimum element is " .
    findMin($arr8, 0, $n8 - 1) . "\n";
 
$arr9 = array(3, 4, 5, 1, 2);
$n9 = sizeof($arr9);
echo "The minimum element is " .
    findMin($arr9, 0, $n9 - 1) . "\n";
 
// This code is contributed by ChitraNayal
?>

Javascript

 
// Javascript program to find minimum element in a sorted and rotated array
     
     
    function findMin(arr,low,high)
    {
        // This condition is needed to handle the case when array
        // is not rotated at all
        if (high < low)
            return arr[0];
         
        // If there is only one element left
        if (high == low)
            return arr[low];
         
        // Find mid
        let mid =low + Math.floor((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
    let arr1=[5, 6, 1, 2, 3, 4];
    let n1 = arr1.length;
    document.write("The minimum element is "+ findMin(arr1, 0, n1-1)+"<br>");
     
    let arr2=[1, 2, 3, 4];
    let n2 = arr2.length;
    document.write("The minimum element is "+ findMin(arr2, 0, n2-1)+"<br>");
     
    let arr3=[1];
    let n3 = arr3.length;
    document.write("The minimum element is "+ findMin(arr3, 0, n3-1)+"<br>");
     
    let arr4=[1,2];
    let n4 = arr4.length;
    document.write("The minimum element is "+ findMin(arr4, 0, n4-1)+"<br>");
     
    let arr5=[2,1];
    let n5 = arr5.length;
    document.write("The minimum element is "+ findMin(arr5, 0, n5-1)+"<br>");
     
    let arr6=[5, 6, 7, 1, 2, 3, 4];
    let n6 = arr6.length;
    document.write("The minimum element is "+ findMin(arr6, 0, n6-1)+"<br>");
     
    let arr7=[1, 2, 3, 4, 5, 6, 7];
    let n7 = arr7.length;
    document.write("The minimum element is "+ findMin(arr7, 0, n7-1)+"<br>");
     
    let arr8=[2, 3, 4, 5, 6, 7, 8, 1];
    let n8 = arr8.length;
    document.write("The minimum element is "+ findMin(arr8, 0, n8-1)+"<br>");
     
    let arr9=[3, 4, 5, 1, 2];
    let n9 = arr9.length;
    document.write("The minimum element is "+ findMin(arr9, 0, n9-1)+"<br>");
     
    // This code is contributed by avanitrachhadiya2155
     

---

输出：

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

如何处理重复?

上述方法在最坏情况下(如果所有元素都相同)需要 O(N)。
下面是在 O(log n) 时间内处理重复项的代码。

C++

// C++ program to find minimum element in a sorted
// and rotated array contating duplicate elements.
#include 
using namespace std;
 
// Function to find minimum element
int findMin(int arr[], int low, int high)
{
    while(low < high)
    {
        int mid = low + (high - low)/2;
        if (arr[mid] == arr[high])
            high--;
        else if(arr[mid] > arr[high])
            low = mid + 1;
        else
            high = mid;
    }
    return arr[high];
}
 
// Driver code
int main()
{
    int arr1[] = {5, 6, 1, 2, 3, 4};
    int n1 = sizeof(arr1)/sizeof(arr1[0]);
    cout << "The minimum element is " << findMin(arr1, 0, n1-1) << endl;
  
    int arr2[] = {1, 2, 3, 4};
    int n2 = sizeof(arr2)/sizeof(arr2[0]);
    cout << "The minimum element is " << findMin(arr2, 0, n2-1) << endl;
  
    int arr3[] = {1};
    int n3 = sizeof(arr3)/sizeof(arr3[0]);
    cout<<"The minimum element is "<

Java

// Java program to find minimum element
// in a sorted and rotated array contating
// duplicate elements.
import java.util.*;
import java.lang.*;
 
class GFG{
     
// Function to find minimum element
public static int findMin(int arr[],
                          int low, int high)
{
    while(low < high)
    {
        int mid = low + (high - low) / 2;
        if (arr[mid] == arr[high])
            high--;
             
        else if(arr[mid] > arr[high])
            low = mid + 1;
        else
            high = mid;
    }
    return arr[high];
}
 
// Driver code
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));
}
}
 
// This is code is contributed by SoumikMondal

蟒蛇3

# Python3 program to find
# minimum element in a sorted
# and rotated array contating
# duplicate elements.
 
# Function to find minimum element
def findMin(arr, low, high):
   
    while (low < high):
        mid = low + (high - low) // 2;
         
        if (arr[mid] == arr[high]):
            high -= 1;
        elif (arr[mid] > arr[high]):
            low = mid + 1;
        else:
            high = mid;
    return arr[high];
 
# Driver code
if __name__ == '__main__':
   
    arr1 = [5, 6, 1, 2, 3, 4];
    n1 = len(arr1);
    print("The minimum element is ",
          findMin(arr1, 0, n1 - 1));
 
    arr2 = [1, 2, 3, 4];
    n2 = len(arr2);
    print("The minimum element is ",
          findMin(arr2, 0, n2 - 1));
 
    arr3 = [1];
    n3 = len(arr3);
    print("The minimum element is ",
          findMin(arr3, 0, n3 - 1));
 
    arr4 = [1, 2];
    n4 = len(arr4);
    print("The minimum element is ",
          findMin(arr4, 0, n4 - 1));
 
    arr5 = [2, 1];
    n5 = len(arr5);
    print("The minimum element is ",
          findMin(arr5, 0, n5 - 1));
 
    arr6 = [5, 6, 7, 1, 2, 3, 4];
    n6 = len(arr6);
    print("The minimum element is ",
          findMin(arr6, 0, n6 - 1));
 
    arr7 = [1, 2, 3, 4, 5, 6, 7];
    n7 = len(arr7);
    print("The minimum element is ",
          findMin(arr7, 0, n7 - 1));
 
    arr8 = [2, 3, 4, 5, 6, 7, 8, 1];
    n8 = len(arr8);
    print("The minimum element is ",
          findMin(arr8, 0, n8 - 1));
 
    arr9 = [3, 4, 5, 1, 2];
    n9 = len(arr9);
    print("The minimum element is ",
          findMin(arr9, 0, n9 - 1));
 
# This code is contributed by Princi Singh

C＃

// C# program to find minimum element
// in a sorted and rotated array
// contating duplicate elements.
using System;
 
class GFG{
     
// Function to find minimum element
public static int findMin(int []arr, int low,
                          int high)
{
    while (low < high)
    {
        int mid = low + (high - low) / 2;
        if (arr[mid] == arr[high])
            high--;
             
        else if (arr[mid] > arr[high])
            low = mid + 1;
        else
            high = mid;
    }
    return arr[high];
}
 
// Driver code
public static void Main(String []args)
{
    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, n6 - 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 Amit Katiyar

Javascript

// JavaScript program to find minimum element in a sorted
// and rotated array contating duplicate elements.
   
// Function to find minimum element
function findMin(arr, low, high)
{
    while(low < high)
    {
        let mid = Math.floor(low + (high - low)/2);
        if (arr[mid] == arr[high])
            high--;
        else if(arr[mid] > arr[high])
            low = mid + 1;
        else
            high = mid;
    }
    return arr[high];
}
 
var arr1 = [5, 6, 1, 2, 3, 4];
var n1 = arr1.length;
document.write("The minimum element is " + findMin(arr1, 0, n1-1) + "<br>");
 
var arr2 = [1, 2, 3, 4];
var n2 = arr2.length;
document.write("The minimum element is " + findMin(arr2, 0, n2-1) + "<br>");
 
var arr3 = [1];
var n3 = arr3.length;
document.write("The minimum element is " + findMin(arr3, 0, n3-1) + "<br>");
 
var arr4 = [1, 2];
var n4 = arr4.length;
document.write("The minimum element is " + findMin(arr4, 0, n4-1) + "<br>");
 
var arr5 = [2, 1];
var n5 = arr5.length;
document.write("The minimum element is " + findMin(arr5, 0, n5-1) + "<br>");
 
var arr6 = [5, 6, 7, 1, 2, 3, 4];
var n6 = arr6.length;
document.write("The minimum element is " + findMin(arr6, 0, n6-1) + "<br>");
 
var arr7 = [1, 2, 3, 4, 5, 6, 7];
var n7 = arr7.length;
document.write("The minimum element is " + findMin(arr7, 0, n7-1) + "<br>");
 
var arr8 = [2, 3, 4, 5, 6, 7, 8, 1];
var n8 = arr8.length;
document.write("The minimum element is " + findMin(arr8, 0, n8-1) + "<br>");
 
var arr9 = [3, 4, 5, 1, 2];
var n9 = arr9.length;
document.write("The minimum element is " + findMin(arr9, 0, n9-1) + "<br>");
 
// This code is contributed by probinsah

输出：

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。