【leetcode】33. Search in Rotated Sorted Array【java】

【题目】

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.
【二分思路】
分情况讨论，数组可能有以下三种情况：



然后，再看每一种情况中，target在左边还是在右边，其中第一种情况还可以直接判断target有可能不在数组范围内。
【Java代码】

[java] view
plain copy

 





public class Solution {  

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

        int len = A.length;  

        if (len == 0) return -1;  

        return binarySearch(A, 0, len-1, target);  

    }  

      

    public int binarySearch(int[] A, int left, int right, int target) {  

        if (left > right) return -1;  

          

        int mid = (left + right) / 2;  

        if (A[left] == target) return left;  

        if (A[mid] == target) return mid;  

        if (A[right] == target) return right;  

          

        //图示情况一  

        if (A[left] < A[right]) {   

            if (target < A[left] || target > A[right]) {    //target不在数组范围内  

                return -1;  

            } else if (target < A[mid]) {                   //target在左边  

                return binarySearch(A, left+1, mid-1, target);  

            } else {                                        //target在右边  

                return binarySearch(A, mid+1, right-1, target);  

            }  

        }   

        //图示情况二  

        else if (A[left] < A[mid]) {   

            if (target > A[left] && target < A[mid]) {      //target在左边  

                return binarySearch(A, left+1, mid-1, target);  

            } else {                                        //target在右边  

                return binarySearch(A, mid+1, right-1, target);  

            }  

        }   

        //图示情况三  

        else {   

            if (target > A[mid] && target < A[right]) {     //target在右边  

                return binarySearch(A, mid+1, right-1, target);  

            } else{                                         //target在左边  

                return binarySearch(A, left+1, mid-1, target);  

            }  

        }  

    }  

}  

下面是参考网上的思路，其中if (target == A[left]) 和 if (target == A[right]) 两个判断是我自己加上的，因为加上这两个判断后，下面分情况讨论时就不用考虑target等于边界的情况了。

[java] view
plain copy

 





public class Solution {  

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

        int len = A.length;  

        if (len == 0) {  

            return -1;  

        } else if (len == 1) {  

            return target==A[0] ? 0 : -1;  

        }  

          

        int left = 0, right = len-1;  

        while (left < right) {  

            int mid = left + (right-left)/2;  

            if (target == A[mid]) {  

                return mid;  

            } else if (target == A[left]) {  

                return left;  

            } else if (target == A[right]) {  

                return right;  

            }  

              

            //第一种情况中，target不在数组范围内  

            if (A[left]<A[right] && (target<A[left] || target>A[right])) {  

                return -1;  

            }  

              

            //第一、二种情况的左边，即连续上升的左边，且target在这段内  

            if (A[left]<A[mid] && target>A[left] && target<A[mid]) {  

                right = mid - 1;  

                continue;  

            }  

              

            //第一、三种情况的右边，即连续上升的右边，且target在这段内  

            if (A[mid]<A[right] && target>A[mid] && target<A[right]) {  

                left = mid + 1;  

                continue;  

            }  

              

            //如果上面情况都不满足，那么可能在第二种情况的右边  

            if (A[mid] > A[right]) {  

                left = mid + 1;  

                continue;  

            }  

              

            //如果上面情况都不满足，第三种情况的左边  

            if (A[left] > A[mid]) {  

                right = mid - 1;  

                continue;  

            }  

        }  

          

        return -1;  

    }  

}  

个人感觉还是自己那样写思路比较清晰。

2015/3/30更新

[java] view
plain copy

 





public class Solution {  

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

        int l = 0;  

        int r = A.length - 1;  

        while (l <= r) {  

            int mid = (l + r) / 2;  

            if (target == A[mid]) return mid;  

            if (A[l] <= A[r]) {  

                if (target < A[mid]) r = mid - 1;  

                else l = mid + 1;  

            } else if (A[l] <= A[mid]) {  

                if (target > A[mid] || target < A[l]) l = mid + 1;  

                else r = mid - 1;  

            } else {  

                if (target < A[mid] || target > A[r]) r = mid - 1;  

                else l = mid + 1;  

            }  

        }  

        return -1;  

    }  

}  

我自己的代码 2016-12-23

public class Solution {

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

        int minIdx = findMinIdx(nums);

        if (target == nums[minIdx]){

            return minIdx;

        }

        int m = nums.length;

        int start = (target <= nums[m - 1]) ? minIdx : 0;

        int end = (target > nums[m - 1]) ? minIdx : m -1;

        while (start <= end){

            int mid = start + (end - start) / 2;

            if (nums[mid] == target){

                return mid;

            } else if (target > nums[mid]){

                start = mid + 1;

            } else {

                end = mid -1;

            }

        }

        return -1;

    }

    public int findMinIdx(int[] nums){

        int start = 0;

        int end = nums.length -1;

        while (start < end){

            int mid = start + (end - start) / 2;

            if (nums[mid] > nums[end]){

                start = mid + 1;

            } else {

                end = mid;

            }

        }

        return start;

    }

}