LeetCode系列(六)- Search in Rotated Sorted Array

---

 　　假设按照升序排序的数组在预先未知的某个点上进行了旋转。

　　( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

　　搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

　　你可以假设数组中不存在重复的元素。

　　你的算法时间复杂度必须是 O(log n) 级别。

 

示例：

　　输入: nums = [4,5,6,7,0,1,2], target = 0

　　输出: 4

 

解法：

1. 先给一种时间复杂度为 O(N)的解法。

思路是先遍历数组，找到旋转点的位置。再对数组排序，使用二分查找法。得到索引位置。(索引位置+二分查找法)%数组长度。就是当前位置

    public int search(int[] nums, int target) {
        if (nums.length==0) {
            return -1;
        }
        int max = nums[0];
        int num = 0;
        for (int i=0;i<nums.length;i++) {
            if (nums[i]>max) {
                max=nums[i];
                num++;
            }
        }
        // num指旋转点所在位置
        num++;
        Arrays.sort(nums);
        int search = Arrays.binarySearch(nums, target);
        if (search<0) {
            return -1;
        }
        return  (search+num)%nums.length;
    }

2. 时间复杂度为O(logN)解法，直接调用二分查找法。

public int search(int[] nums, int target) {
        if (nums.length==0) {
            return -1;
        }
        int start = 0;
        int end = nums.length-1;
        while (start<=end) {
            int mid = (start+end)/2;
            if (nums[mid]==target) {
                return 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;
    }