搜索旋转排序数组

题目描述

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

法一：

最开始想到的思路就是先找到旋转点（数组中最小的元素），然后判断target位于旋转点的哪一侧，位于左侧，就去左侧二分，位于右侧，就去右侧二分。

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 mid = (left + right) / 2;
      if (nums[mid] > nums[mid + 1])
        return mid + 1;
      else {
        if (nums[mid] < nums[left])//右半部分有序，该去左半部分找
          right = mid - 1;
        else//左半部分有序，该去右半部分找
          left = mid + 1;
      }
    }
    return 0;
  }
//二分查找
  public int search(int left, int right) {
    while (left <= right) {
      int mid = (left + right) / 2;
      if (nums[mid] == target)
        return mid;
      else {
        if (target < nums[mid])
          right = mid - 1;
        else
          left = mid + 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 (nums[rotate_index] == target)
      return rotate_index;
    if (rotate_index == 0)
      return search(0, n - 1);//位于右侧（没有旋转）
    if (target < nums[0])//位于右侧
      return search(rotate_index, n - 1);
    return search(0, rotate_index);//位于左侧
  }
}

法二：

查看题解后发现了另一种方法。同样是使用二分，只不过没有寻找中间值，而是直接二分，然后在二分时判断该去哪边找。

class Solution {
    public int search(int[] nums, int target) {
        int len = nums.length;
        if (len == 0) {
            return -1;
        }

        int left = 0;
        int right = len - 1;

        while (left < right) {
            int mid = (left + right) >>> 1;
            if (nums[mid] > nums[right]) {
                // 前有序，包括中间数
                // 6 7 8 9 1 2
                if (nums[left] <= target && target <= nums[mid]) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            } else {
                // 后有序，包括中间数
                // 6 7 1 2 3 4 5 6
                if (nums[mid] < target && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
        }
        if (nums[left] == target) {
            return left;
        }
        return -1;
    }
}