[leetcode]Search in Rotated Sorted Array II

这道题目仍然是二分，去掉不可能的部分。用了递归，在重复的情况下，就是有可能最左边的和最右边的相等，此时就不能直接判断出区间外的元素，左右两边同时递归。有重复元素的时候，在bad case的时候会退化为O（n）

public class Solution {

    public boolean search(int[] A, int target) {

        return search(A, target, 0, A.length-1);

    }

    

    private boolean search(int[] A, int target, int left, int right)

    {

        if( left > right) return false;

        if (left == right) return (A[left] == target);

        if (A[left] < A[right] && (target < A[left] || target > A[right])) return false;

        if (A[left] > A[right] && target > A[right] && target < A[left]) return false;

        int mid = left + (right - left) / 2;

        if (A[mid] == target) return true;

        else

        {

            return search(A, target, left, mid-1) || search(A, target, mid+1, right);

        }

    }

}

网上有个思路更简洁，二分。如果相等导致不能二分，则直接跳过这个重复的元素。

class Solution {

public:

    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;

    }

};