Leetcode 33-Search In Rotated Sorted Array

    题目：

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

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

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

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

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

    思路：这个题目有点烦，想通了其实也挺简单的。题给数组是一个旋转对称数组，稍微想象一下就是两个上升图形。这两个图形有几个特点：

    1：左边的图形一定比右边的高。

    2：两个图形都是升序。

    搞明白这两个特点这题就好解了。

    首先分情况

    1:target在左边高的图形上（通过与nums[0]对比，大于[0]就在此线段上，原理为图形特点）。此时还分两种情况，一是nums[mid]在低的图形上，此时直接把high赋值给mid-1；第二种是nums[mid]在高的图形上，此时用二分思想判定target在low和mid之间，还是mid和high之间。

    2:target在右边（同上，通过与nums[n-1]对比）。此时也有两种情况，mid指向高的图形上，此时直接把low设为mid+1就行；第二种是mid和target同边，用二分思想判断。

    代码如下：

class Solution {
    public int search(int[] nums, int target) {
        int n =nums.length;
        int low=0;
        int high=n-1;
        int mid;
        
        if(nums==null||n==0)
        {
            return -1;
        }
        
        if(target<nums[0]&&target>nums[n-1])
        {
            return -1;
        }
        
        if(target==nums[0]){
            return 0;
        }
        
        if(target==nums[n-1])
        { 
            return n-1;
        }
        
        if(target>nums[0])
        {
            while(low<=high){
                mid=(low+high)/2;
                if(target==nums[mid])
                {
                    
                    return mid;
                }
               else if(nums[mid]<nums[0])
                {
                    high=mid-1;
                    
                }
                
                else//在同一边了 
                {
                    if(target<nums[mid])
                    {
                        high=mid-1;
                    }
                    else if(target>nums[mid]){
                        
                        low=mid+1;
                    }
                    
                }
            }
            if(low>high){
                
                return -1;
            }
        }
        
        
        if(target<nums[n-1])
        {
            
            while(low<=high){
            mid=(low+high)/2;
                if(target==nums[mid])
                {
                    
                    return mid;
                }
                
                
                if(nums[mid]>=nums[0])
                {
                    low=mid+1;
                    
                }
                
                else if(nums[mid]>target)
                {
                    high=mid-1;
                }
                
                else if(nums[mid]<target)
                {
                    
                    low=mid+1;
                }
                    
            }
            
            if(low>high){
                return -1;
            }
            
        }
        
        
        return -1;
    }
}

    值得一提的是，判断mid是不是与target同边时，由于mid是向左偏。所以有一种很特殊的情况，就是mid指向nums[0]，且上方线段只有一个nums[0]，high指向下方第一个数，所以nums[mid]是有可能等于nums[0]的，所以比较时要考虑这一点。

    结果如下：

    结论：用时最好的算法思路和我差不多，先看mid的值在哪边，再判定target的相对位置来分情况。