Find Minimum in Rotated Sorted Array 典型二分查找

https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array/

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.

解题思路：

最朴素的O(n)的方法，就是找到突然变小的那个元素，肯定是最小的。否则就说明所有元素一直变大，本来就是排序的，则返回第一个元素。

public class Solution {
    public int findMin(int[] num) {
        if(num.length == 0){
            return 0;
        }
        
        int min = num[0];
        
        for(int i = 0; i < num.length; i++){
            if(num[i] < min){
                return num[i];
            }
        }
        return min;
    }
}

 不过本题还有一个二分查找的方法，可以将时间复杂度降为O(lgN)。代码如下。

public class Solution {
    public int findMin(int[] num) {
        if(num.length == 0){
            return 0;
        }
        
        if(num.length == 1){
            return num[0];
        }
        
        int start = 0;
        int end = num.length - 1;
        int min = Integer.MAX_VALUE;
        
        if(num[start] < num[end]){
            return num[start];
        }
        
        while(start <= end){
            if(start == end){
                return Math.min(min, num[start]);
            }
            int mid = (start + end) / 2;
            
            if(num[start] <= num[mid]){
                min = Math.min(min, num[start]);
                start = mid + 1;
            }else{
                min = Math.min(min, num[mid]);
                end = mid - 1;
            }
        }
        return min;
    }
}

二分查找是一个很简单，却很难完全写对的算法，编程珠玑里写道，差不多只有10%的程序员能正确的实现它。问题主要处在边界变量的定义，和循环条件的定义上。让我们从程序的开头看起。

将end定义为length - 1，就意味着这是一个[0, length - 1]的左右都闭合的区间，所以循环的条件一定是start <= end。所以再到循环内部，start = mid + 1, end = mid - 1，都是因为这是一个闭合的区间，这样做才不会漏元素。

如果end定义为length，那么就意味着这个区间是左闭合有开的，[0, length)。所以后面while的条件就变为start < end，循环内部，start = mid + 1, end = mid。

这样理解起来就不会出错。其实这就是循环不变式的概念，loop invariant。可以参考下面的页面，对于这个比较基础的知识介绍的很好。

http://www.cppblog.com/converse/archive/2009/09/21/96893.aspx

update: 2015/03/11

下面一段我写的，更为简洁的代码。看几个例子，7 8 0 1 2 3 4 5 6，mid=2；3 4 5 6 7 8 0 1 2，mid=7。

mid > end的时候，代表前面是排序的，可能折断点在后面，于是start=mid+1。

mid < end的时候，代表后面是排序的，可能折断点在前面，但是这时候不能end = mid - 1。为什么？看一个例子，4 5 0 1 2。这时mid < end，但是mid就是折断点，所以这时end = mid。

mid == end的时候，说明当前mid就是最小值。

为什么mid要和end比较，不能和start？因为除非在start==end的情况，否则mid不可能等于end，但是start可能等于mid，比如只有两个元素，[2,1]，这时start==mid<end，所以返回的是错误的2。

另外还要注意一点。while内部更新start和end的各个条件要符合互相没有交集，但是合起来又可以组成全集的原理。因为前半句违背了，可能一次更新多次start和end，这样有些范围就跳过不搜索了。后半句违背了，可能使得start和end得不到更新，引起死循环。

这个性质其实也和上面说的循环不变式同理，需要体会。

public class Solution {
    public int findMin(int[] num) {
        int start = 0;
        int end = num.length - 1;
        while(start <= end){
            int mid = (start + end) / 2;
            if(num[end] == num[mid]){
                return num[mid];
            }
            if(num[end] < num[mid]){
                start = mid + 1;
            }
            if(num[end] > num[mid]){
                end = mid;
            }
        }
        return -1;
    }
}

 二分查找的题目很多，基本原理就是这样，但是具体情况，mid的值和哪个值比较，状态变化和终止的条件，变化万千，需要细细体会。

这道题是二分查找里比较经典的题目，也比较灵活，相应条件的定义和start、end的转换可以有多种写法。