Leetcode 33 Search in Rotated Sorted Array

思路一： 看到时间复杂度logn，就知道要用binary search。那么第一种方法是two pass binary search。先用一次binary search把rotate point找出来，然后再判断target在rotate pointer前还是后。判断好了就再进行一次binary search。得到答案。附上代码：

class Solution {
  int [] nums;
  int target;

  public int find_rotate_index(int left, int right) {
    if (nums[left] < nums[right])
      return 0;

    while (left <= right) {
      int pivot = (left + right) / 2;
      if (nums[pivot] > nums[pivot + 1])
        return pivot + 1;
      else {
        if (nums[pivot] < nums[left])
          right = pivot - 1;
        else
          left = pivot + 1;
      }
    }
    return 0;
  }

  public int search(int left, int right) {
    /*
    Binary search
    */
    while (left <= right) {
      int pivot = (left + right) / 2;
      if (nums[pivot] == target)
        return pivot;
      else {
        if (target < nums[pivot])
          right = pivot - 1;
        else
          left = pivot + 1;
      }
    }
    return -1;
  }

  public int search(int[] nums, int target) {
    this.nums = nums;
    this.target = target;

    int n = nums.length;

    if (n == 0)
      return -1;
    if (n == 1)
      return this.nums[0] == target ? 0 : -1;

    int rotate_index = find_rotate_index(0, n - 1);

    // if target is the smallest element
    if (nums[rotate_index] == target)
      return rotate_index;
    // if array is not rotated, search in the entire array
    if (rotate_index == 0)
      return search(0, n - 1);
    if (target < nums[0])
      // search in the right side
      return search(rotate_index, n - 1);
    // search in the left side
    return search(0, rotate_index);
  }
}

思路二： one pass binary search。其实就是不去特意先找rotate pointer。就进行常规的binary search。只是要多加一些判断条件来缩小search范围。具体算法思路我直接截图solution，因为讲的已经很好了。下面给出思路以及代码：

class Solution {
  public int search(int[] nums, int target) {
    int start = 0, end = nums.length - 1;
    while (start <= end) {
      int mid = start + (end - start) / 2;
      if (nums[mid] == target) return mid;
      else if (nums[mid] >= nums[start]) {
        if (target >= nums[start] && target < nums[mid]) end = mid - 1;
        else start = mid + 1;
      }
      else {
        if (target <= nums[end] && target > nums[mid]) start = mid + 1;
        else end = mid - 1;
      }
    }
    return -1;
  }
}

最后展示一下我自己的one pass solution，写的很差，见谅：

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(mid < nums.length - 1 && nums[mid] > nums[mid + 1] && left != right){
                if(target >= nums[left]){right = mid;}
                else{left = mid + 1;}
            }else{
                if(target == nums[mid]){
                    return mid;
                }else if(target > nums[mid]){
                    if(target >= nums[left] && nums[mid] < nums[left]){right = mid - 1;}        
                    else{left = mid + 1;}
                }else{
                    if(((mid > 0 && nums[mid - 1] < nums[mid] && nums[mid] < nums[left])) || (nums[mid] > nums[left] && nums[mid + 1] > nums[mid] && target >= nums[left])){right = mid - 1;}
                    else{left = mid + 1;}
                }
            }  
        }
        return - 1;
    }
}