【二分】Search in Rotated Sorted Array II

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.

方法一：先找出pivot点，即最小值的下标

因为有重复元素，所以要在I的基础上进行特殊处理

public class Solution {    public int findPivot(int [] a){        int l = 0;        int r = a.length-1;        int pivot = l;                while(l<r && a[l] >= a[r]){        if(r - l == 1){        pivot = r;        break;        }            int mid = (l+r)/2;                        if(a[l] == a[r] && a[l] == a[mid])//若三个值都相等，则找出a[i]<a[i-1]的下标i            return MinInOrder(a, l, r);                        if(a[mid] < a[l]) r = mid;            else l = mid;        }        return pivot;    }public int MinInOrder(int [] num, int l, int r){int res = num[l];for(int i=l+1; i<=r; i++){    if(num[i-1] > num[i]){res = i;break;}}return res;}        public int binaySearch(int [] a, int target, int l, int r){        while(l <= r){            int mid = (l+r)/2;            if(a[mid] < target) l = mid+1;            else if(a[mid] > target) r = mid-1;            else return mid;        }        return -1;    }        public boolean search(int[] A, int target) {        if(A.length == 0) return false;        int pivot = findPivot(A);        //System.out.println(pivot);        int res1 = binaySearch(A, target, 0, pivot-1);        if(res1 != -1) return true;        else return binaySearch(A, target, pivot, A.length-1)>=0;    }}

方法二：递归

转自：http://leetcodenotes.wordpress.com/2013/10/13/leetcode-search-in-rotated-sorted-array-12-%E8%A2%AB%E6%97%8B%E8%BD%AC%E4%B8%80%E6%AC%A1%E7%9A%84sorted%E6%95%B0%E7%BB%84%EF%BC%8C%E6%89%BEx%E7%9A%84index/

public boolean search(int[] A, int target) {  return find(A, 0, A.length - 1, target) >= 0;}private int find(int[] arr, int p, int q, int x) {  if (p > q)    return -1;  int mid = (p + q) / 2;  if (arr[mid] == x)    return mid;   if (arr[p] < arr[mid]) { //left is ordered, right is broken    if (arr[p] <= x && x <= arr[mid]) // x is in the left ordered part      return find(arr, p, mid - 1, x);    else //x doesn't belong to left orderd part      return find(arr, mid + 1, q, x);  } else if (arr[p] > arr[mid]) {//left is broken, so right is ordered    if (arr[mid] <= x && x <= arr[q])      return find(arr, mid + 1, q, x);    else      return find(arr, p, mid - 1, x);  } else { // arr[p] = arr[mid], don't know which side is broken    if (arr[mid] == arr[q]) {      int leftResult = find(arr, p, mid - 1, x);      return leftResult == -1 ? find(arr, mid + 1, q, x) : leftResult;    } else { //mid is not equals right, so left is all repeats, search right      return find(arr, mid + 1, q, x);    }  }}

方法三：其实挺无趣的，就是直接将数组排序再进行二分，虽然也可以通过，但时间复杂度却高了不少

public class Solution {    public int binaySearch(int [] a, int target, int l, int r){        while(l <= r){            int mid = (l+r)/2;            if(a[mid] < target) l = mid+1;            else if(a[mid] > target) r = mid-1;            else return mid;        }        return -1;    }        public boolean search(int[] A, int target) {        if(A.length == 0) return false;        Arrays.sort(A);        int res1 = binaySearch(A, target, 0, A.length-1);        if(res1 != -1) return true;        return false;    }}