Search in Rotated Sorted Array

https://leetcode.com/problems/search-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).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

解题思路：

这时一道二分查找题，与标准的binary search不同，它的数组没有排序，在某个位置被rotate了。所以我们无法直接A[mid]的值和target的大小直接用mid去更新start或者end，但是一定有方法，我们来看看。

例如一个A[]：6 7 0 1 2 4 5，mid为1。如果我们要搜1，这种情况下target<A[mid]，一定在前半段。如果要找比A[mid]大的，就不一定了，有可能在后半段，也有可能在被rotate到前面去的几个（6、7）里面。那么如何判断到底在前面还是后面？就看target和A[end]也就是5的大小，如果>5，一定是被rotate到前面去的，就在前面，否在在后半段。

这样就清楚了。可是写出来出错，为什么？

考虑另一个例子，A[]：2 4 5 6 7 0 1，这种情况被rotated到前面的元素多，mid为6。这时的判断就完全相反了，比A[mid]大的，一定在后半段，但是比A[mid]小的，要和A[start]比大小，然后看到底在前半段还是后半段。

这里我们可以看到，要先根据A[mid]和与[start]或者A[end]的大小来分别讨论，但是整体思路还是比较清晰的。题目不是太难。

public class Solution {

    public int search(int[] A, int target) {

        int start = 0;

        int end = A.length - 1;

        

        while(start <= end){

            int mid = (start + end) / 2;

            if(target == A[mid]){

                return mid;

            }

            if(A[mid] < A[start]){

                //后半段一定比mid大，所以这时target一定在前面

                if(target < A[mid]){

                    end = mid - 1;

                }

                //有可能在后半段，也有可能在rotate到前面的那部分

                if(target > A[mid]){

                    if(target <= A[end]){

                        start = mid + 1;

                    }else{

                        end = mid - 1;

                    }

                }

            }else{

                //前半段一定比mid小，所以这时target一定在后面

                if(target > A[mid]){

                    start = mid + 1;

                }

                if(target < A[mid]){

                    if(target < A[start]){

                        start = mid + 1;

                    }else{

                        end = mid - 1;

                    }

                }

            }

        }

        return -1;

    }

}

update 2015/07/12:

更新了代码，先判断target是不是在有序的那段，否则就在另一段

public class Solution {

    public int search(int[] nums, int target) {

        if(nums.length == 0) {

            return -1;

        }

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

        while(start <= end) {

            int mid = (start + end) / 2;

            if(nums[mid] == target) {

                return mid;

            }

            // 必须是小于等于，因为start可能等于mid

            if(nums[start] <= nums[mid]) {

                if(target < nums[mid] && target >= nums[start]) {

                    end = mid - 1;

                } else {

                    start = mid + 1;

                }

            } else {

                if(target > nums[mid] && target <= nums[end]) {

                    start = mid + 1;

                } else {

                    end = mid - 1;

                }

            }

        }

        return -1;

    }

}