LeetCode第33题：搜索旋转排序数组（中等）

最新推荐文章于 2020-07-19 21:05:58 发布

new_whiter

最新推荐文章于 2020-07-19 21:05:58 发布

阅读量248

点赞数

分类专栏：学生文章标签： LeetCode第33题：搜索旋转排序数组（中等）

本文链接：https://blog.csdn.net/new_whiter/article/details/103489497

版权

学生专栏收录该内容

148 篇文章 0 订阅

订阅专栏

LeetCode第33题：搜索旋转排序数组（中等）

题目：假设按照升序排序的数组在预先未知的某个点上进行了旋转。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。
解法一：采用了双指针的办法，我的想法应该还挺好想的。

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;
        int a=nums[Left],b=nums[Right];
        while(Right>=Left){
            if(target==nums[Right])  return Right;
            if(target==nums[Left])  return Left;
            if(target<nums[Right]){
                if(nums[Right] <= b){
                    b=nums[Right];
                }else{
                    break;
                }
                Right--;
            }else if(target>nums[Left]){
                if(nums[Left] >= a){
                    a=nums[Left];
                }else{
                    break;
                }
                Left++;
            }else{
                break;
            }
        }
        return -1;
    }
}

解法二：官方解法采用了二分法

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);
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。