查找有序旋轉數組中的最小值

題目：給定一個有序數組，但是數組尾部的k個元素被移到了頭部，查找該數組中的最小值。例如A={4,5,0,1,2},最小元素爲0。

1、假設數組中沒有重複元素

public int findMin(int[] nums) {
        if(nums.length==1)return nums[0];
        int left=0,right=nums.length-1,mid;
        int min=nums[0];
        while(left<=right){
            mid=left+(right-left)/2;
            if(nums[mid]<min){
                right=mid;
                min=nums[mid];
            }else{
                left=mid+1;
            }
        }
        return min;
    }

2、數組中有重複元素
只有數組頭尾相同時，纔會無法判斷數組那部分數據有序，因此當首位相同時只需要移動尾指針直到首尾字符不相同，這時問題又退化到情況1。

 public int findMin(int[] nums) {
        if (nums == null || nums.length == 0) {
            return Integer.MIN_VALUE;
        }

        int start = 0, end = nums.length - 1;

        //only need to add the following while loop on top of the solution 
        //for Part I
        //if two line segments have overlap, remove the overlap.
        //so, the problem can be solved as Part I
        while (nums[end] == nums[start] && end > start) {
            end--;
        }

        while (start < end) {
            //if the linear monotonically increasing in [start, end]
            if (nums[start] < nums[end]) {
                return nums[start];
            }

            int mid = start + (end - start) / 2;
            if (nums[mid] >= nums[start]) {
                start = mid + 1;
            }
            else {
                end = mid;
            }
        }

        return nums[start];
    }

如何將旋轉數組變爲正常數組？

public static void roatArray(int[] val) {
        //find the roat pos
        int i=0,len=val.length-1;
        while(i<len-1){
            if(val[i]<val[i+1])i++;
            else break;
        }
        //0...i and i+1...len is sorted
        //step 1:reverse 0...len
        reverse(val,0,len);
        //step 2:reverse 0...len-i-1
        reverse(val,0,len-i-1);
        //step 3:reverse len-i...len
        reverse(val,len-i,len);
    }

    public static void reverse(int[] val, int s, int e) {
        int temp;
        for (int i = s,j=e; i < j; i++,j--) {
            temp = val[i];
            val[i] = val[j];
            val[j] = temp;
        }
    }

在旋轉數組中查找指定的元素：

// get target
    public static int getValue(int[] val,int target){
        int start=0,end=val.length-1;
        int mid=0;
        while(start<=end){
            mid=(start+end)/2;
            if(target==val[mid])return mid;
            while(start<=end&&val[end]==val[start])end--;
            if(val[mid]<val[end]){
                //right is sorted
                if(target>val[mid]&&target<=val[end]){
                    start=mid+1;
                }else if(target<val[mid]||target>val[end]){
                    end=mid-1;
                }
            }else{
                //left is sorted
                if(target>=val[start]&&target<val[mid]){
                    end=mid-1;
                }else if(target<val[start]||target>val[mid]){
                    start=mid+1;
                }
            }
        }
        return -1;
    }