剑指Offer：6 旋转数组的最小数字(二分法的应用)-优快云博客

本文介绍了一种使用改进二分法查找旋转数组中最小元素的方法。通过调整循环终止条件和边界，有效地解决了经典二分查找无法直接应用的问题，并提供了一个处理特殊情况的顺序查找算法。

一开始想要用二分法，但不知道如何处理，之后看了书上的处理思路，然后自己动手写代码，一遍过。

对基本方法的灵活应用还是很重要的。

主要是二分查找的循环终止条件和左右边界的每次的调整和经典二分查找有所改动。

也可以用其他查找方法试一试，对比一下效果。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size()==0) return 0;
        
        int left = 0, right = rotateArray.size()-1;
        int mid;
        if(rotateArray[left]<rotateArray[right]){
            return rotateArray[left];
        }
        
        while(left<right-1){
            mid = (left+right)/2;
            if(rotateArray[mid]>=rotateArray[left]){
                left = mid;
            }
            else if(rotateArray[mid]<=rotateArray[right]){
                right = mid;
            }
        }
        return rotateArray[right];
    }
};

以上代码对于【10，1,10,10,10】这样的case会出现问题，需要加入一些特例的处理：特例情况下顺序查找

class Solution {
public:
    int minArray(vector<int>& numbers) {
        const int n = numbers.size();
        if(n == 0) return 0; 
            //throw new std::exception("Invalid parameters");

        int left = 0, right = n-1;
        if(numbers[left] < numbers[right]) 
            return numbers[0];

        while(left < right-1) {
            int mid = left + (right - left)/2;
            //对于特殊的case的特殊处理
            if(numbers[left] == numbers[right] && numbers[left] == numbers[mid]) {
                return Inorder(numbers, left, right);
            }

            if(numbers[mid] >= numbers[left]) {
                left = mid;
            }
            else if(numbers[mid] <= numbers[right]) {
                right = mid;
            }
        }
        return numbers[right];
    }

    int Inorder(vector<int>& numbers, int left, int right) {
        int res = numbers[left];
        for(int i = left+1; i <= right; i++) {
            res = min(res, numbers[i]);
        }
        return res;
    } 
};