LeetCode 33，81. Search in Rotated Sorted Array i, ii

1. 题目描述

33

Suppose a sorted array 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.

81

Follow up for “Search in Rotated Sorted Array”:
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

2. 解题思路

这是一个有序数组， 所以我们可以尝试使用二分的思路去解决这个问题， 不过需要注意一个问题，使用二分法的时候， 边界问题的判断。 这里由于不太记得住二分法究竟怎么写了， 于是在自己的代码中加了一个补丁， 特别判断一下 start == stop - 1 的情形

而对于 81 题， 由于允许重复， 我们只需要对有重复部分区域采用遍历即可。

3. code

3.1 code 33

class Solution {
public:
    int search(vector<int>& nums, int target) {
        return helper(nums, 0, nums.size() - 1, target);
    }
private:
    // x -->  [start, stop];
    int helper(vector<int>& nums, int start, int stop, int target){
        int res = -1;
        while (start <= stop){
            int mid = start + ((stop - start) >> 1);
            if (nums[mid] == target)
                return mid;

            if (start == stop)
                break;

            // 我是补丁
            if (start == stop - 1){
                if (nums[stop] == target)
                    return stop;
                break;
            }

            if (nums[start] < nums[mid]){
                if (nums[start] <= target && nums[mid] > target)
                    stop = mid - 1;
                else
                    start = mid + 1;
            }
            else{
                if (nums[mid] < target && nums[stop] >= target)
                    start = mid + 1;
                else
                    stop = mid - 1;
            }
        }

        return res;
    }
};

3.2 81 code

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        return helper(nums, 0, nums.size() - 1, target) >= 0;
    }

private:
    // x -->  [start, stop];
    int helper(vector<int>& nums, int start, int stop, int target){
        int res = -1;
        while (start <= stop){
            int mid = start + ((stop - start) >> 1);
            if (nums[mid] == target)
                return mid;

            if (start == stop)
                break;

            // 我是补丁
            if (start == stop - 1){
                if (nums[stop] == target)
                    return stop;
                break;
            }

            // 遍历搜索
            if (nums[start] == nums[mid] || nums[stop] == nums[mid] || nums[start] == nums[stop]){
                for (int i = start; i != stop + 1; i++){
                    if (nums[i] == target)
                        return i;
                }

                return -1;
            }

            if (nums[start] < nums[mid]){
                if (nums[start] <= target && nums[mid] > target)
                    stop = mid - 1;
                else
                    start = mid + 1;
            }
            else{
                if (nums[mid] < target && nums[stop] >= target)
                    start = mid + 1;
                else
                    stop = mid - 1;
            }
        }

        return res;
    }
};

4. 大神解法

4.1 33 demo1 先修复旋转数组， 再查找

这段代码， 主要是通过先利用二分查找， 找到最小值的位置， 然后根据这个最小值的位置， 可以推算出该旋转数组和该数组之间的转化关系， 利用二分查找即可， what a brilliant solution!!!

class Solution {
public:
    int search(int A[], int n, int target) {
        int lo=0,hi=n-1;
        // find the index of the smallest value using binary search.
        // Loop will terminate since mid < hi, and lo or hi will shrink by at least 1.
        // Proof by contradiction that mid < hi: if mid==hi, then lo==hi and loop would have been terminated.
        while(lo<hi){
            int mid=(lo+hi)/2;
            if(A[mid]>A[hi]) lo=mid+1;
            else hi=mid;
        }
        // lo==hi is the index of the smallest value and also the number of places rotated.
        int rot=lo;
        lo=0;hi=n-1;
        // The usual binary search and accounting for rotation.
        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;
    }
};

4.2 33 demo2 思路和我们的一致

public class Solution {
public int search(int[] A, int target) {
    int lo = 0;
    int hi = A.length - 1;
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (A[mid] == target) return mid;

        if (A[lo] <= A[mid]) {
            if (target >= A[lo] && target < A[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        } else {
            if (target > A[mid] && target <= A[hi]) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
    }
    return A[lo] == target ? lo : -1;
}
}

4.3 81 demo

由于当发生重复的时候， A[m] == A[l], 可以将 l++， 因为这个l 的值会在后面的内容中再次出现的。。。

bool search(int A[], int n, int key) {
    int l = 0, r = n - 1;
    while (l <= r) {
        int m = l + (r - l)/2;
        if (A[m] == key) return true; //return m in Search in Rotated Array I
        if (A[l] < A[m]) { //left half is sorted
            if (A[l] <= key && key < A[m])
                r = m - 1;
            else
                l = m + 1;
        } else if (A[l] > A[m]) { //right half is sorted
            if (A[m] < key && key <= A[r])
                l = m + 1;
            else
                r = m - 1;
        } else l++;
    }
    return false;
}