Leetcode 33. Search in Rotated Sorted Array

题目描述

将有序数组打乱，然后从中查找一个数据的下标
Suppose an array sorted in ascending order 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.

Your algorithm’s runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4
Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

要求

时间复杂度为O(log(n)) ，不用O(n),

思路

时间复杂度类似于二分查找，求出中间的元素 mid ,mid中间数总能把整个数组序列

1. 第一种情况是直接A[mid] == target , 则直接返回即可。
2. A[mid]与A[right]构成一个递增序列
   并且tagert 在这个递增序列的内，取右边的部分
   如果target不在递增序列部分， 取左边的序列继续上述相同的操作
3. A[left]与A[right]构成一个递增序列,
   并且target在左边这个递增序列内，取左边的部分
   如果target不在递增序列部分，取右边的序列继续上面的步骤
   原数组：0 1 2 4 5 6 7 假设查找0
   情况1： 6 7 0 1 2 4 5 中间元素为1，1的右边为有序 r = mid-1
   情况2： 2 4 5 6 7 0 1 中间元素为6，6的左边为有序 l = mid+1
   情况3： 5 6 7 0 1 2 4 中间元素为 0 ， 0的右边为有序 查找成功

总结起来的规律就是
A[mid] = target, 返回mid，否则

(1) A[mid] < A[end]: A[mid+1 : end] sorted
A[mid] < target <= A[end] 右半，否则左半。

(2) A[mid] > A[end] : A[start : mid-1] sorted
A[start] <= target < A[mid] 左半，否则右半。

代码（Java）

public int find(int [] nums, int target){
    if(nums==null||nums.length==0)
        return -1;
    int l=0, n = nums.length;
    int r = n-1;
    while(l<=r){
    int mid = (l+r)/2;
    if(nums[mid]==target)
        return mid;
    if(nums[mid]<nums[r]){
         if(target>nums[mid]&& nums[mid]>=target)
              l = mid+1;
         esle
             r =mid -1;
    }
    else
    {
        if(target<numd[mid]&& nums[l]<=target)
             r =mid-1;
        else
            l = mid+1;
    }
}

代码（递归）

public int solutiuon_res(int[] nums, int target) {
        if (nums.length == 0 || nums == null) return -1;

        int n = nums.length;

        return find(nums, target, 0, n - 1);

     }
        public int find(int []nums,int target, int left,int right){

        if(left>right)return  -1;
        int mid =( right+left)/2;
        if(nums[mid]==target)
            return mid;
        if(nums[mid]<nums[right]) {
            if (nums[mid] < target && nums[right] >= target)
                find(nums,target,mid+1, right );
            else
                find(nums,target,left,mid-1);
        }
        else
        {
            if(nums[left]<=target && target<nums[mid])
                find(nums,target, left, mid-1);
            else
                find(nums, target, mid+1, right);
        }
        return -1;
        }