在有序旋转数组中找到最小值

import java.util.Scanner;

public class Main {
    public static int find(int p, int r, int n, int arr[]) {
        while (p <= r) {
            int mid = p + (r - p) / 2;
            if (arr[p] <= arr[mid] && arr[mid] <= arr[r]) {
                return (arr[p] <= arr[mid + 1] ? arr[p] : arr[mid + 1]);
            } else if (arr[p] <= arr[mid]) {
                p = mid + 1;
            } else if (arr[mid] <= arr[r]) {
                r = mid - 1;
            }
        }
        return 0;
    }

    public static void main(String[] args) {
        int n = 0;
        int arr[] = new int[10000000];
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        System.out.println(find(0, n - 1, n, arr));
    }
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, x, Min=INT_MAX;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>x;
        Min = min(Min, x);
    }
    cout<<Min<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    while(cin>>n)
    {
        vector<int> vc(n+1,0);
        for(int i=0;i<n;i++)
        {
            cin>>vc[i];
        }
        int low=0,high=n-1,mid=0;
        while(low<high)
        {
            if(vc[low]<vc[high])
            {//这里是严格升序，所以直接可以返回，每次是在low-high这个范围里找最小值
                break;
            }
            mid=(low+high)/2;
            if(vc[low]<=vc[mid])// 2 2 2 2 1 2
            {//说明vc[low -mid]这一段是非降序的，表明min不在这里
                low=mid+1;
            }
            else
            {//vc[low] > vc[mid],最小值肯定在  low - mid范围内
                high=mid;
            }
        }
        cout<<vc[low]<<endl;
    }
    return 0;
}

import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        Arrays.sort(arr);
        System.out.print(arr[0]);
    }
}

int findMinimumInRotatedSortedArray(const vector& arr) {
    if (arr.size() == 1) return arr[0];
    int L = 0, R = arr.size()-1;
    while (L <= R) {
        if (arr[R] >= arr[L]) return arr[L];
        int mid = (L + R) / 2;
        if (mid + 1 <= R && arr[mid+1] < arr[mid])
            return arr[mid+1];
        if (mid - 1 >= L && arr[mid-1] > arr[mid])
            return arr[mid];
        if (arr[mid] > arr[L])
            L = mid+1;
        else
            R = mid-1;
    }
    return arr[L];
}

测资好像不是很足够，上面的代码可以通过，试试[3, 1, 3]發现答案不是正确的

二分思路，每次去除一半的数据

n = int(input())
l = list(map(int, input().split()))
left, right = 0, n-1
while left < right:
    if l[left] < l[right]:
        break
    mid = (left + right) >> 1
    if l[mid] > l[right]:
        left = mid+1
    else:
        right = mid
print(l[left])