LeetCode第[33]题(Java)：Search in Rotated Sorted Array

题目：在翻转有序中搜索

难度：Medium

题目内容：

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).

翻译：

假设一个按升序排序的数组在事先不知道旋转点的情况下翻转。

(即。0,1,2,4,5,6,7可能变成4,5,6,7,0,1,2）。

您获得了搜索的目标值。如果在数组中找不到它的索引，否则返回-1。

数组中不存在重复。

您的算法的运行时复杂度应该为O（log n）

我的思路：要复杂度O（log n），但是数组只是基本有序，而排序算法的最佳情况也要O（N），本弱鸡想不出什么很好方法。。。

　　　　　那就强行上吧，先插入排序一波，再二分法搜索。

　　　　　然而最后要返回下标，再排序后下标会发生变化，所以再新建一个数组存储下标，在排序过程中，此数组相应的值跟着一起移动。

MyCode：

    public int search(int[] nums, int target) {
        int[] index = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            index[i] = i;
        }        
        insertSort(nums, index);
        return binaryFind(nums, target, index);
    }
    
    static int binaryFind(int[] nums, int target, int[] index) {
        int low = 0;
        int high = nums.length - 1;
        while (low <= high) {
            int mid = low + (high - low)/2;
            if (nums[mid] == target) {
                return index[mid];
            } else if (nums[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }
    
    static void insertSort(int[] nums, int[] index) {
        for (int i = 1; i < nums.length; i++) {
            int temp = nums[i];
            int temp2 = index[i];
            int j = i - 1;
            while (j > -1 && nums[j] > temp) {
                nums[j+1] = nums[j];
                index[j+1] = index[j];
                j--;
            }
            nums[j+1] = temp;
            index[j+1] = temp2;
        }
    }

我的算法复杂度：O（N²），因为插入排序的最坏情况就是O（N²）。

编码过程中出现的问题：

1、把插入排序的逻辑给忘了。。

答案代码：

    public int search(int[] A, int target) {
        int n = A.length;
        int lo=0,hi=n-1;
        while(lo<hi){
            int mid=(lo+hi)/2;
            if(A[mid]>A[hi]) lo=mid+1;
            else hi=mid;
        }
        int rot=lo;
        lo=0;hi=n-1;
        while(lo<=hi){
            int mid=(lo+hi)/2;
            int realmid=(mid+rot)%n;
            if(A[realmid]==target)return realmid;
            if(A[realmid]<target)lo=mid+1;
            else hi=mid-1;
        }
        return -1;
    }

答案复杂度：O（logN）

答案思路：首先利用数组局部仍然有序的特点，和 A[mid]>A[hi] 的条件，以二分法定位到最小的那一个值的下标，注意当 A[mid]<=A[hi] 的时候，应该是hi=mid，因为此时的mid有可能就是最小点，所以不能放过。【当要求的点不是直接定位的mid的时候（等循环结束），mid 有可能就是最终的值，下一层的 lo 和 hi 的取值不能都把mid排除， 其中一个就是mid】

找到最小点后，记录下来，然后继续对原数组进行二分法搜索，然而，参与比较的mid应该改成realMid=(mid+rot)%n

以[4,5,6,7,0,1,2]为例，找到最小值（真起点）0的下标4后，取mid=（0+6）/2 = 3，而真正的中点下标应该等于(mid+rot)%n = （3+4）%7 = 0

之后的向左右移动是一样的，所以还是变化mid的值即可。