旋转数组四道题通用二分解法

主要思路都是判断nums[mid] 与 nums[r] 之间的关系 如果nums[mid] <= nums[r] 则表示右边的数组是有序的
在旋转数组中任意取一个划分点（旋转点的话两边都是有序的），一定会有一边是有序的。以此来做二分
当数组中有重复的元素时，需要移动端点来去除重复值。

leetcode 33

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        //什么时候是 < ，什么时候是 <=
        while (l <= r) {
            int mid = (r - l) / 2 + l;
            // cout<<nums[l]<<" "<<nums[mid]<<" "<<nums[r]<<endl;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] <= nums[r]) {
                //右半边有序
                if (nums[mid] <= target && target <= nums[r]) l = mid + 1;
                else  r = mid - 1; 
            } else {
                //左半边有序
                if (nums[l] <= target && target <= nums[mid]) r = mid - 1;
                else l = mid + 1;
            }
        }
        return -1;
    }

leetcode 81

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

    bool search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        //什么时候是 < ，什么时候是 <=
        while (l <= r) {
            int mid = (r - l) / 2 + l;
            if (nums[mid] == target) {
                return true;
            } else if(nums[mid] < nums[r]) {
                //右半边有序
                if(nums[mid] <= target && target <= nums[r]) l = mid + 1;
                else r = mid - 1;
            } else if (nums[mid] == nums[r]) {
                //重复的增加这一个选项排除右端点
                --r;
            } else {
                //左半边无序的话就是右半边有序，因为在旋转数组中找一个点，当这个点不是旋转点
                //的时候，两边总会有一个有序的
                if(nums[l] <= target && target <= nums[mid]) r = mid - 1;
                else l = mid + 1;
            }
        }
        return false;
    }

leetcode 153

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。

    int findMin(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        
        //目标是找到一个值使得
        while (l <= r) {
            int mid = (r - l) / 2 + l;
            //都是先比较左边与中点的值
            //这里是比较nums[l] <= nums[mid] 为什么要=呢？是因为mid是可能等于l
            if (nums[mid] < nums[r]) {
                //右半边有序，左半边被旋转了，最小值在左边
                r = mid ;
            } else if(nums[mid] == nums[r]) {
                --r;
            } else {
                //旋转数组，任取一个点，两边必定有一边是有序的（旋转点的话两边都是有序的）
                //左边有序 最小值在右边
                l = mid + 1;
            }
        }
        return nums[l];
    }

leetcode 154

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
注意数组中可能存在重复的元素。

    int findMin(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;

        while (l <= r) {

            int mid = (r - l) / 2 + l;
            if (nums[r] > nums[mid]) {
                //右边有序，最小值在左边
                r = mid;
            } else if(nums[r] < nums[mid]) {
                //右边无序，在右边查找
                l = mid + 1;
            } else if (nums[r] == nums[mid]) {
                --r;
            }
        }
        return nums[l];
    }