LeetCode Top 100 Liked Questions 33. Search in Rotated Sorted Array(Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 33. Search in Rotated Sorted Array(Java版; Medium)

题目描述

概括一下就是在旋转数组中寻找target, 找到的话返回其索引, 没找到的话返回-1
Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm's runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4
Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

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

    }
}

第一次做, 有序数组, 查找, logN, 直接想到用二分法; 数组不一定完全有序, 先用二分法找到分界线(数组最小值的索引), 确定查找的范围, 再次使用二分法查找target

/*
有序数组, 找某个数, 时间复杂度要求O(logN), 直接想到二分查找法
分解问题:
1.找到边界(二分法)
2.根据边界判断在哪部分寻找这个数(二分法)
*/
class Solution {
    public int search(int[] nums, int target) {
        if(nums==null || nums.length==0)
            return -1;
        
        int left=0, right=nums.length-1, mid;
        //数组中没有重复的数字
        if(nums[0] < nums[nums.length-1]){
            left = 0; 
            right = nums.length-1;
        }
        else{
            //在这里, 设定left指向第一个递增数组的末尾, right指向第二个递增数组的开头
            while(left<=right){
                mid = left + ((right - left)>>1);
                //mid在第一个递增数组中
                if(nums[mid] > nums[left])
                    left = mid;
                //mid在第二个递增数组中
                else if(nums[mid] < nums[left])
                    right = mid;
                //由于数组中没有重复的数字, 所以如果nums[mid] == nums[left], 说明left+1==right, 此时mid==left, 
                //也就是说left指向第一个递增数组的末尾, right指向第二个递增数组的开头
                else{
                    if(nums[0] == target)
                        return 0;
                    else if(nums[0] > target){
                        left = right;
                        right = nums.length-1;
                    }
                    else{
                        left = 1;
                        right = right -1;
                    }
                    break;
                }
            }
        }
        //在left, right范围中查找target
        while(left<=right){
            mid = left + ((right - left)>>1);
            if(nums[mid] > target)
                right = mid - 1;
            else if(nums[mid] < target)
                left = mid + 1;
            else
                return mid;
        }
        
        return -1;
    }
}