Paste_Image.png

My code:

public class Solution {
    public int findMin(int[] nums) {
        if (nums == null || nums.length == 0)
            return 0;
        int minIndex = findMin(0, nums.length - 1, nums);
        
        return nums[minIndex];
    }
    
    private int findMin(int begin, int end, int[] nums) {
        if (begin == end)
            return begin;
        int mid = (begin + end) / 2;
        if (nums[mid] < nums[end]) { // right part is sorted so minimun exists in the left
            while (mid - 1 >= begin && nums[mid] == nums[mid - 1])
                mid--;
            return findMin(begin, mid, nums);
        }
        else if (nums[mid] > nums[end]){// left part is sorted so minimun exists in the right
            int i = mid + 1;
            while (i + 1 <= end && nums[i + 1] == nums[i])
                i++;
            return findMin(i, end, nums);
        }
        else
            return findMin(0, end - 1, nums);
    }
}

My test result:

Paste_Image.png

這次題目加了重復，會出現一種情況，即中間等于末尾。
這時，是不確定，最小值在哪側的。
比如，
3, 3, 1, 3 是在右側。
再比如，
1, 1, 3, 1 是在左側。
但是，有一點是確定的，末尾處的值，可能是最小值，但一定不是唯一的最小值。
所以，直接重新處理數組， (begin, end - 1) 即可。

**
總結: Array
**

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int findMin(int[] nums) {
        if (nums == null || nums.length == 0)
            return 0;
        int begin = 0;
        int end = nums.length - 1;
        while (begin < end) {
            int middle = (begin + end) / 2;
            if (nums[middle] < nums[end]) {
                end = middle;
                int i = end;
                while (i >= 1 && nums[i] == nums[i - 1])
                    i--;
                if (i == 0)
                    return nums[0];
                else
                    end = i;
            }
            else if (nums[middle] > nums[end]){
                begin = middle + 1;
                int i = begin;
                while (i < nums.length - 1 && nums[i] == nums[i + 1])
                    i++;
                if (i == nums.length - 1)
                    return nums[nums.length - 1];
                else
                    begin = i;
            }
            else {
                end = end - 1;
            }
        }
                
        return nums[begin];
    }
}

這道題目加強了難度。我也是兩遍之后才過。
主要是這么一種情況。
3 3 1 3
或者是
1 3 3 3
這種情況下，nums[middle] == nums[end] 但是最小值卻出現在不同的地方。
所以不知道該是end = middle 還是 begin = middle + 1, 這是不確定的。
那么就可以直接， end = end - 1,縮短一位，繼續尋找。
因為nums[middle] == nums[end], 所以就算nums[end]是最小值，那么還有nums[middle]存在，一定不會把最小值漏掉的。

Anyway, Good luck, Richardo!

My code:

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

reference:
https://discuss.leetcode.com/topic/59136/very-simple-java-solution-based-on-binary-search

much simpler code

Anyway, Good luck, Richardo! -- 09/21/2016