Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4
5 6 7 0 1 2).

Find the minimum element.

You may assume no duplicate exists in the array.

不知道这道题为什么难度是Medium，感觉蛮简单的。

仅仅须要找到第一个大于它后面的数，它后面的数就是旋转排序数组中最小的数。

将返回结果初始化为数组中的第一个元素。这样就能够将结果统一起来。

时间复杂程度是O(N)。

runtime:4ms

class Solution {

public:

    int findMin(vector<int>& nums) {

       int result=nums[0];

       auto iter=nums.begin();

       for(;iter!=nums.end()-1;iter++)

       {

           if(*iter>*(iter+1))

           {

                result=*(iter+1);

                break;

           }

       }

       return result;

    }

};

然后看了下Discuss，发现了一个使用二分查找思想的代码。漫有意思的，也有分析。以后在碰到排序好的数组进行了一些变形或一些附加说明时注意使用二分查找的思想。时间复杂程度是O(logN)。

链接

In this problem, we have only three cases.

Case 1. The leftmost value is less than the rightmost value in the list: This means that the list is not rotated. e.g> [1 2 3 4 5 6 7 ]

Case 2. The value in the middle of the list is greater than the leftmost and rightmost values in the list. e.g> [ 4 5 6 7 0 1 2 3 ]

Case 3. The value in the middle of the list is less than the leftmost and rightmost values in the list. e.g> [ 5 6 7 0 1 2 3 4 ]

As you see in the examples above, if we have case 1, we just return the leftmost value in the list. If we have case 2, we just move to the right side of the list. If we have case 3 we need to move to the left side of the list.

Following is the code that implements the concept described above.

int findMin(vector<int>& nums) {

    int left = 0,  right = nums.size() - 1;

    while(left < right) {

        if(nums[left] < nums[right])

            return nums[left];

        int mid = (left + right)/2;

        if(nums[mid] > nums[right])

            left = mid + 1;

        else

            right = mid;

    }

    return nums[left];

}