Find Minimum in Rotated Sorted Array I & II

Find Minimum in Rotated Sorted Array I

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.

 Notice

You may assume no duplicate exists in the array.

Example

Given [4, 5, 6, 7, 0, 1, 2] return 0

分析：

Although array is rotated, either its left half part or right half part is sorted. We just need to disgard the sorted part, and continue to search in the rotated part. Unlike regular binary search in which start = mid + 1 or end = mid - 1, we need to set start = mid or end = mid, this is to make sure the remaining half is still rotated. When there are only two numbers left, the right one must be the smallest value in the whole rotated array.

public class Solution {
    /**
     * @param num: a rotated sorted array
     * @return: the minimum number in the array
     * cnblogs.com/beiyeqingteng/
     */
    public int findMin(int[] num) {
        if (num == null || num.length == 0) return -1;
        if (num.length == 1) return num[0];
        
        int start = 0;
        int end = num.length - 1;
        
        if (num[start] < num[end]) return num[start];
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (start + 1 == end) return num[end]; // eventually, there will be only two numbers left
            if (num[start] < num[mid]){
                start = mid; // we don't use start = mid + 1 is to avoid the case in which the remaining array 
                            // is not rotated sorted array.
            } else {
                end = mid;
            }
        }
        return 0;
    }
}

遞迴的方法：

class Solution {
    public int findMin(int[] nums) {
        if (nums == null || nums.length == 0) return -1;
        return findMinHelper(nums, 0, nums.length - 1);
    }
    
    private int findMinHelper(int[] nums, int start, int end) {
        if (start == end) return nums[start];
        if (end - start == 1) return Math.min(nums[start], nums[end]);
        int mid = start + (end - start) / 2;
        
        if (nums[start] < nums[end]) {
            return nums[start];
        }
        
        if (nums[start] < nums[mid]) {
            return findMinHelper(nums, mid + 1, end);
        } else {
            // [3, 1, 2]
            return findMinHelper(nums, start, mid);
        }
    }
}

 

Find Minimum in Rotated Sorted Array II

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.

 Notice

The array may contain duplicates.

Example

Given [4,4,5,6,7,0,1,2] return 0.

Analysis:

In this case, we have duplicates in the array, so, we cannot compare arr[start] and arr[mid] to determine which part is the rotated part. In stead, we have check all the numbers in the left part. 

public class Solution {

    public int findMin(int[] num) {
        if (num == null || num.length == 0) return -1;
        if (num.length == 1) return num[0];
        
        int start = 0;
        int end = num.length - 1;
        
        if (num[start] < num[end]) return num[start]; // handle case  4 5 6 7 0 1 2
        while (start <= end) {
            if (start + 1 == end) return num[end]; // eventually, there will be only two numbers left
            int mid = start + (end - start) / 2;
            if (nonDecreasing(num, start, mid)){
                start = mid; 
            } else {
                end = mid;
            }
        }
        return 0;
    }
    
    private boolean nonDecreasing(int[] A, int i, int j) {
        for (int k = i; k < j; k++) {
            if (A[k] > A[k + 1] ) return false;
        }
        return true;
    }
}

 遞迴解法：

class Solution {
    public int findMin(int[] nums) {
        if (nums == null || nums.length == 0) return -1;
        return findMinHelper(nums, 0, nums.length - 1);
    }
    
    private int findMinHelper(int[] nums, int start, int end) {
        if (start == end) return nums[start];
        if (end - start == 1) return Math.min(nums[start], nums[end]);
        int mid = start + (end - start) / 2;
        boolean firstHalfSorted = sorted(nums, start, mid);
        boolean secondHalfSorted = sorted(nums, mid, end);
        
        if (firstHalfSorted && secondHalfSorted) {
            return nums[start];
        }
        
        if (firstHalfSorted) {
            return findMinHelper(nums, mid + 1, end);
        } else {
            return findMinHelper(nums, start, mid);
        }
    }
    
    private boolean sorted(int[] A, int i, int j) {
        for (int k = i; k < j; k++) {
            if (A[k] > A[k + 1] ) return false;
        }
        return true;
    }
}