Find Minimum in Rotated Sorted Array -- leetcode

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.

简单翻译为： 寻找循环有序数组的最小值  ，假定没有重复的值存在。

题目源址

class Solution {
public:
        int findMin(vector<int> &num) {
                if (!num.size()) return -1;

                int low = 0;
                int high = int(num.size())-1;

                for (;;) {
                        if (low == high || num[low] < num[high])
                                return num[low];

                        const int mid = low + (high-low)/2;

                        if (num[mid] < num[high])
                                high = mid;
                        else
                                low = mid+1;
                }
        }
};

递归写法为：

int findMin(int arr[], int low, int high)
{
        if (low == high || arr[low] < arr[high])
                return arr[low];

        const int mid = low + (high-low)/2;

        if (arr[mid] < arr[high])
                return findMin(arr, low, mid);
        else
                return findMin(arr, mid+1, high);
}

两者接口不一样，前者是为了适应leetcode的要求，后者是为了和下面的代码作对比。

以上算法，我是在阅读下面一篇博客后完成的。主要区别为收敛条件，感觉自己的更简单一些。

Find the minimum element in a sorted and rotated array

附上该篇博客的代码：

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);
}

思路简介：

两种方法都是采取二分。

区别为，我的实现，关注最小值，逐步缩小范围，直到一个点（缩小到区间只有一个值）。

而他的思路，充分关注并利用断崖（相邻两值，前者大于后者）。所以他的比较条件虽多，但有可能提前捕捉到最小值，而退出循环。

本题目是基于没有重复的值存在，关于有重复的值则在另一篇继续讨论。