[Leetcode]33(81). Search in Rotated Sorted Array I, II

题目大意：

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.

一. 没有重复元素

分析：{0，1，2，4，6，7，8}

情况1：{ 8，0，1，2，4，6，7}

情况2：{2，4，6，7，8，0，1}

I. nums[mid] = target时, 返回索引；

II. nums[mid] != target时： 

   1.两种情况都有半边是完全排序好的

   2.原数组起始元素被转到nums[mid]的左半边，如情况1，nums[mid]<nums[start]

      (1). target在右半边，则依次逼近，因为右半边就是正常的排序好的数组

      (2). target在左半边，就是else的情况

   3.原数组起始元素被转到nums[mid]的右半边，如情况2，也是情况1的else，即nums[mid]>=nums[start]

      (1). target在左半边，则依次逼近，因为左半边就是正常的排序好的数组

      (2). target在右半边，就是else的情况 

public class Solution {
    /** 
     *@param A : an integer rotated sorted array
     *@param target :  an integer to be searched
     *return : an integer
     */
    public int search(int[] A, int target) {
        if(A==null || A.length==0){
            return -1;
        }
        
        int start=0,end=A.length-1;
        while(start+1<end){
           int mid=start+(end-start)/2;
           if(A[mid]==target){
               return mid;
           }
           if(A[start]<A[mid]){
               if(A[start]<=target && target<=A[mid]){
                   end=mid;
               }else{
                   start=mid;
               }
           }else{
               if(A[mid]<=target && target<=A[end]){
                   start=mid;
               }else{
                   end=mid;
               }
           }
        }
        
        if(A[start]==target){
            return start;
        }
        if(A[end]==target){
            return end;
        }
        return -1;
    }
}

二. 有重复元素

九章的解释是说这题在面试中不会让实现完整程序

考点是能否想到最坏情况比如序列 {1，1，...1，1}中有1个0寻找target=0，此时复杂度退化到O(n)

由于for循环的时间复杂度是O(n)，直接写个for循环就好

public class Solution {
    /** 
     * param A : an integer ratated sorted array and duplicates are allowed
     * param target :  an integer to be search
     * return : a boolean 
     */
    public boolean search(int[] A, int target) {
        if(A==null || A.length==0){
            return false;
        }
        for(Integer n:A){
            if(n==target){
                return true;
            }
        }
        return false;
    }
}

二分实现分析：{1，2，3，3，3，3}

如果不能确定是否为递增：{3，3，3，3，1，2}，跳过此时的start看向下一位

I. nums[mid] = target时, 返回索引；

II. nums[mid] != target时： 

    所以在最坏情况下，算法的复杂度退化成了O(n) ，比如序列 {2，2， 2，2，2，2}中寻找target=1。

public class Solution {
    /** 
     * param A : an integer ratated sorted array and duplicates are allowed
     * param target :  an integer to be search
     * return : a boolean 
     */
    public boolean search(int[] A, int target) {
        if(A==null || A.length==0){
            return false;
        }
        
        int start=0;
        int end=A.length-1;
        while(start+1<end){
            int mid=start+(end-start)/2;
            if(A[mid]==target){
                return true;
            }
            if(A[start]<A[mid]){
                if(A[start]<=target && target<=A[mid]){
                    end=mid;
                }else{
                    start=mid;
                }
            }else if(A[start]>A[mid]){
                if(A[mid]<=target && target<=A[end]){
                    start=mid;
                }else{
                    end=mid;
                }
            }else{                                      //确定不了是否递增，就跳过重复值往下一个看即可
                start++;
            }
        }
        
        if(A[start]==target){
            return true;
        }else if(A[end]==target){
            return true;
        }else{
            return false;
        }
    }
}