【旋转数组】LeetCode中旋转数组问题总结

共四道题：
1、33. Search in Rotated Sorted Array - 旋转数组中的查找（没有重复元素）
2、81. Search in Rotated Sorted Array II - 旋转数组中的查找（有重复元素）
3、153. Find Minimum in Rotated Sorted Array - 旋转数组中最小值（没有重复元素）
4、154. Find Minimum in Rotated Sorted Array II - 旋转数组中最小值（有重复元素）

LeetCode - 33. Search in Rotated Sorted Array

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

Input: nums = [4,5,6,7,0,1,2], target = 0   Output: 4

Input: nums = [4,5,6,7,0,1,2], target = 3   Output: -1

  对于区间 [left, right]，每次二分，一定能保证区间 [left, mid] 或者区间 [mid, right] 中，至少有一个是有序的。

int search(vector<int>& nums, int target) {
    int l = 0, r = nums.size() - 1;
    while(l <= r) {
        const int mid = l + (r - l) / 2;
        if(nums[mid] == target) return mid;
        if(nums[mid] < nums[r]) {   // 右边一定有序
            if(target >= nums[mid] && target <= nums[r])
                l = mid + 1;
            else
                r = mid - 1;
        }
        else {  // 左边一定有序
            if(target >= nums[l] && target <= nums[mid])
                r = mid - 1;
            else
                l = mid + 1;
        }
    }
    return -1;
}

LeetCode - 81. Search in Rotated Sorted Array II

You are given a target value to search. If found in the array return true, otherwise return false.

Input: nums = [2,5,6,0,0,1,2], target = 0   Output: true
Input: nums = [2,5,6,0,0,1,2], target = 3   Output: false

  上一题的变体，就是变成了有重复元素，查找的元素如果存在返回 true，不存在返回 false。
  这道题比上一题复杂之处在于，上边的题 nums[mid] == nums[r] 的情况不需要特殊考虑，而这道题就需要：

1. nums[mid] < nums[r]，此时能保证右边有序
2. nums[mid] > nums[r]，此时能保证左边有序
3. nums[mid] == nums[r]
   3.1 nums[l] < nums[mid]，左边有序
   3.2 nums[l] > nums[mid]，右边有序
   3.3 nums[l] == nums[mid]，无法确定两部分中哪部分是有序的，++l 或 --r 都可以。

bool search(vector<int>& nums, int target) {
    int l = 0, r = nums.size() - 1;
    while(l <= r) {
        const int mid = l + (r - l) / 2;
        if(nums[mid] == target) return true;
        if(nums[mid] < nums[r] || 
          (nums[mid] == nums[r] && nums[l] > nums[mid])) {      // 右边有序
            if(target >= nums[mid] && target <= nums[r])
                l = mid + 1;
            else
                r = mid - 1;
        }
        else if(nums[mid] > nums[r] || 
               (nums[mid] == nums[r] && nums[l] < nums[mid])) { // 左边有序
            if(target >= nums[l] && target <= nums[mid])
                r = mid - 1;
            else
                l = mid + 1;
        }
        else // nums[mid] == nums[r]
            --r;    // or ++l;
    }
    return false;
}

153. Find Minimum in Rotated Sorted Array

  旋转数组中找最小值，只需要讨论两种情况：

1. nums[mid] <= nums[r]，此时右边一定有序，最小值可能在左边，或者刚好 mid 位置，即最小值可能存在的区间为：[l, mid]
2. nums[mid] > nums[r]，此时左边一定有序，最小值一定在右边，即最小值可能存在的区间为：[mid + 1, r]

int findMin(vector<int>& nums) {
    int l = 0, r = nums.size() - 1;
    while(l <= r) {
        const int mid = l + (r - l) / 2;
        if(l == r) return nums[l];  // 重合的地方就是最小值
        if(nums[mid] < nums[r])     // 右边有序
            r = mid;
        else                        // 左边有序
            l = mid + 1;
    }
    return -1;  // should never reach
}

154. Find Minimum in Rotated Sorted Array II

  有重复元素的旋转数组中找最小值，需要讨论：

1. nums[mid] < nums[r]，右边有序，最小值区间：[l, mid]
2. nums[mid] > nums[r]，左边有序，最小值区间：[mid + 1, r]
3. nums[mid] == nums[r]
   3.1 nums[l] < nums[mid]，整个数组有序，最小值：nums[l]
   3.2 nums[l] > nums[mid]，右边都是相同的，最小值区间：[l, mid]
   3.3 nums[l] == nums[mid]，无法确定有序部分，++l 或 --r 都可以。

int findMin(vector<int>& nums) {
    int l = 0, r = nums.size() - 1;
    while(l <= r) {
        const int mid = l + (r - l) / 2;
        if(l == r) return nums[l];   // 重合的地方就是最小值
        if(nums[mid] < nums[r])      // 右边有序
            r = mid;
        else if(nums[mid] > nums[r]) // 左边有序
            l = mid + 1;
        else { // nums[mid] == nums[r]
            if(nums[l] < nums[mid])
                return nums[l];
            else if(nums[l] > nums[mid])
                r = mid;
            else
                --r;    // or ++l;
        }
    }
    return -1;  // should never reach
}