给出三种实现思路，不过还是改进后的暴力最快，256 ms 左右；内置排序是 400ms ，应该是因为基本有序，所以对于快排更不友好

堆

O(n)，因为要将数加入堆中

import java.util.*;

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int[] arr = array;
        if (arr == null || arr.length < 1){
            return 0;
        }
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        for (int i = 0; i < arr.length; i++){
            minHeap.offer(arr[i]);
        }
        return minHeap.poll();
    }
}

暴力

import java.util.*;

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int[] arr = array;
        if (arr == null || arr.length < 1){
            return 0;
        }
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < arr.length; i++){
            res = arr[i] < res ? arr[i] : res;
        }
        return res;

可以改进，不用每次都遍历到底的：

import java.util.*;

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int[] arr = array;
        if (arr == null || arr.length < 1){
            return 0;
        }
        int res = arr[0];
        for (int i = 0; i < arr.length - 1; i++){
            if(arr[i] > arr[i+1]){
                res = arr[i+1];
                break;
            }
        }
        return res;
    }
}

内置排序

内置实现的是三项切分快排，时间复杂度最坏 O(nlogn)，

import java.util.*;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int[] arr = array;
        if (arr == null || arr.length < 1){
            return 0;
        }
        Arrays.sort(arr);
        return arr[0];
    }
}