【LeetCode刷题】33. 搜索旋转排序数组

StudyWinter

于 2020-10-27 22:25:35 发布

阅读量118

点赞数

分类专栏：刷题文章标签： leetcode 算法二分法

本文链接：https://blog.csdn.net/Zhouzi_heng/article/details/109322125

版权

刷题专栏收录该内容

77 篇文章 2 订阅

订阅专栏

给你一个升序排列的整数数组 nums ，和一个整数 target 。

假设按照升序排序的数组在预先未知的某个点上进行了旋转。（例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] ）。

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

示例 1：

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

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

输入：nums = [1], target = 0
输出：-1

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每个值都独一无二
nums 肯定会在某个点上旋转
-10^4 <= target <= 10^4

========================================================================================================

分析：

1、这个题的难度在于整体数据不是有序的，它从某个位置分开，两个部分又是分别有序的，也就是局部有序；

2、可以分别对两部分进行处理，通过分析发现：

比较第一个位置left的值和中间位置mid的值大小

（1）如果第一个位置left的值小于等于中间位置mid的值，此时mid属于左边的序列：

（a）若target>=nums[left]并且target<nums[mid]，也就是target在[left,mid）区间中，那么就在这个区间中进行二分查找；

（b）否则也就是target在(mid,right]区间中，那么就在这个区间内进行二分查找；

（2）第一个位置left的值大于中间位置mid的值，此时mid属于右边序列：

（a）若target>nums[mid]并且target<=num[left]，也就是target在(mid,right]区间中，那么就在这个区间中进行二分查找；

（b）否则target在[left,mid）区间中，那么就在这个区间中进行二分查找；

3、实现

class Solution {
    public int search(int[] nums, int target) {
        // int len = nums.length;
        // if(len==0){
        //     return -1;
        // }
        // int left = 0;                    //左索引
        // int right = len;                 //右索引
        // while(left<right){ 
        //     int mid = (left+right)/2;    //中间索引
        //     if(nums[mid] == target){
        //         return mid;
        //     }
        //     //判断nums[mid]和nums[left]的大小，从而判断mid是在左侧还是右侧
        //     if(nums[mid]>=nums[left]){
        //         //mid在左侧。再判断target在mid的左侧还是右侧
        //         if(nums[left]<=target&&target<nums[mid]){
        //             //target在mid的左侧
        //             right = mid;
        //         }else{
        //             left = mid+1;
        //         }
        //     }else{
        //         if(nums[mid]<target&&target<=nums[right-1]){
        //             //target在mid的右侧
        //             left = mid+1;
        //         }else{
        //             right = mid;
        //         }
        //     }

        // }
        // return -1;

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

参考：https://leetcode-cn.com/problems/search-in-rotated-sorted-array