数组翻转系列

数组翻转后形成的数组，如何在这个数组中查找某个数？如何查找最小值？

查找有序数组当然是二分数组最快了。但是现在这个有序数组经过了翻转，形成了两端有序数组。怎么办？

最好的思想，是把图画出来，再进行分析：

原始数组是一个递增（或非递减）数组，翻转数组则如右图所示。我们可以利用 nums[end] 作为切分参考点，判断每一次mid落在哪一段，然后再通过target和nums[mid], nums[start], nums[end]的关系，判断target是不是落在一段连续的有序区间，再决定下一次搜索向左还是向右。

在不断缩小搜索范围的时候，我们是有可能得到一段连续的有序数组的，很幸运的，按上面的思路写的代码，也能满足只有一段连续区间的情况。

问题1.1：在无重复的翻转数组中查找某个数，返回下标，or - 1。

    int search(vector<int>& nums, int target) {
        int start = 0;
        int end = nums.size() - 1;
        while (start <= end) {
            int mid = start + ((end - start) >> 1);
            if (nums[mid] == target) {
                return mid; //查找到了，返回index
            }
            if (nums[mid] > nums[end]) {  //mid在第一段
                if (target < nums[mid] && target >= nums[start]) { //target在最左一段连续区间
                    end = mid - 1;  //向左边缩小范围查找
                }
                else {
                    start = mid + 1;  //向右边缩小范围查找
                }
            }
            else {   //mid在第二段
                if (target > nums[mid] && target <= nums[end]) {  //target在最右一段连续区间
                    start = mid + 1; //向右边缩小范围查找
                }
                else {
                    end = mid - 1;  //向左边缩小范围查找
                }
            }
        }
        return -1;
    }

问题1.2：在有重复的翻转数组中查找否个数，存在则返回true，反之false。

相比如无重复的翻转数组，有重复的情况要复杂一点，就是当 nums[mid] == 分界点 nums[end] 时，无法判断他是落在第一段还是第二段，但是我们知道

nums[mid] != target，则此时nums[end] !=target，那我们让 end--，直到这个分界点是一个开的点，而不是闭的点。之后的步骤和问题1.1一样。

    bool search(vector<int>& nums, int target) {
        int start = 0;
        int end = nums.size() - 1;
        while (start <= end) {
            int mid = start + ((end - start) >> 1);
            if (nums[mid] == target) {
                return true;
            }
            if (nums[mid] > nums[end]) {
                if (target < nums[mid] && target >= nums[start]) {
                    end = mid - 1;
                }
                else {
                    start = mid + 1;
                }
            }
            else if (nums[mid] < nums[end]) {
                if (target > nums[mid] && target <= nums[end]) {
                    start = mid + 1;
                }
                else {
                    end = mid - 1;
                }
            }
            else {
                end--;
            }
        } 
        return false;
    }

问题2.1：在无重复的翻转数组中查找最小值。

当nums[mid] > nums[end] 说明mid落在第一段，最小值肯定在第二段。所以start = mid + 1。否则mid落在第二段，此时mid落在的点，也可能是最小值，所以end = mid。又因为我们在求mid的时候是向下取整，所以可以保证收敛。而收敛点即是最小点。

    int findMin(vector<int>& nums) {
        int start = 0;
        int end = nums.size() - 1;
        while (start < end) {
            int mid = start + ((end - start) >> 1);
            if (nums[mid] > nums[end]) {
                start = mid + 1;
            }
            else {
                end = mid;
            }
        }
        return nums[start];
    }

问题2.2 : 在有重复的翻转数组中查找最小值。

这个也是个有重复的翻转数组问题，考虑和问题1.2一样，在 nums[mid] == nums[end] 的时候，我们无法判断 mid落在哪一段，但是可以确定，nums[end] 是 <= 最小值的，这时候可以让 end--。也可以收敛到最终结果。

    int findMin(vector<int>& nums) {
        int start = 0;
        int end = nums.size() - 1;
        while (start < end) {
            int mid = start + ((end - start) >> 1);
            if (nums[mid] > nums[end]) {
                start = mid + 1;
            }
            else if (nums[mid] < nums[end]) {
                end = mid;
            }
            else {
                end--;
            }
        }
        return nums[start];
    }