Leetcode33 Search in Rotated Sorted Array

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.

Solution1

• 因为有三个指针：start，mid和end。所以可以先判定start和end的关系来判定数组究竟是否处于旋转的数组中。如果start>end则表明数组旋转，如果start

public class Solution {
    public int search(int[] nums, int target) {
        return help(nums,0,nums.length-1,target);
    }
    public int help(int[] nums, int start, int end, int target){
        if(start>end) return -1;
        int mid = (start+end)/2;
        if(nums[mid]==target) return mid;
        if(mid==start) return nums[end]==target?end:-1;
        if(nums[start]>nums[end]){
            if(nums[mid]>nums[start]){
                if(nums[start]<=target&&target<nums[mid]) return help(nums,start,mid-1,target);//这里有可能target等于start
                else return help(nums,mid+1,end,target);
            }else{
                if(nums[mid]<target&&target<nums[start]) return help(nums,mid+1,end,target);
                else return help(nums,start,mid-1,target);
            }
        }else if(nums[mid]>target) return help(nums,start,mid-1,target);
         else return help(nums,mid+1,end,target);        
    }
}

Solution2

• 解法一虽然能解决问题，但是思路有些混乱。不太清晰。下面的思路是用mid和start来判定当前数组段处于哪一段中。

public class Solution {
    public int search(int[] nums, int target) {
        return help(nums,target,0,nums.length-1);
    }

    public int help(int[] nums, int target, int start, int end){
        if(start>end) return -1;
        int mid = (start+end)/2;
        if(nums[mid] == target) return mid;
        if(nums[mid]>nums[start]){
            if(nums[mid]<target) return help(nums,target,mid+1,end);
            if(nums[start]<=target) return help(nums,target,start,mid-1);//注意这里必须加等号，start可能和target相等。
            if(target<nums[start]) return help(nums,target,mid+1,end);
        }
        if(nums[mid]<nums[start]){
            if(nums[start]<=target) return help(nums,target,start,mid-1);
            if(target>nums[mid]) return help(nums,target,mid+1,end);
            if(target<nums[mid])   return help(nums,target,start,mid-1);
        }

        return help(nums,target,mid+1,end);//mid跟start相等        
    }
}

Solution3

• 将解法2中的思路进行以下整理得到如下代码：

public class Solution {
    public int search(int[] nums, int target) {
        return help(nums,0,nums.length-1,target);
    }
    public int help(int[] nums,int start,int end,int target){
        if(start>end) return -1;
        int mid = (start+end)/2;
        if(nums[mid] == target) return mid;
        if(nums[mid]>=nums[start]){//mid处于上升段
            if(nums[start]<=target&&target<nums[mid]) return help(nums,start,mid-1,target);
            else return help(nums,mid+1,end,target);
        }else{//mid处于后半段
            if(nums[mid]<target&&target<nums[start]) return help(nums,mid+1,end,target);
            else return help(nums,start,mid-1,target);
        }
    }
}

Solution4

• 用迭代的方式来表示解法3得到如下代码：

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;
            if(nums[mid]>=nums[start]){//表明start到mid这段是升序。这里非常容易出错，mid可能跟start相等。已经包含在这个等号当中了。
                if(target>=nums[start]&&target<nums[mid]) end = mid-1;  //target刚好在这段升序当中，注意target有可能等于start
                else start = mid+1;//不在这段升序当中，则只能在后面一段当中
            }else{//反之mid处于后半段当中
                if(target>nums[mid]&&target<nums[start]) start = mid + 1; //这种情况下target一定处于后半段中。
                else end = mid - 1;//其余都处于mid之前。
            }
        }
        return -1;      
    }
}