leetcode-第33题 搜索旋转排序数组

题目

升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array

提示：

• nums 中的每个值都 独一无二

思路

        这个题看似简单，但是着急的情况下还是有可能无法理清思路的。

        首先，这个题暴力法明显是遍历，时间复杂度为O(n)。

        可以利用的信息就是升序序列，且每个数字都不相等，序列以一个点进行了旋转。那么序列就有了两段升序序列，且后半段比前半段的数字都小。我们知道升序序列可以用二分法进行查找，这个题也可以用二分法，但是需要一些额外的考虑。

        如果target大于nums[0]，那么target在左侧升序序列，否则target在右侧升序序列。此时，在两种情况下，分别对比target和middle值的大小来决定二分的演进方向。

        具体逻辑如下代码所示：

class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length <= 0) return -1;
        int left = 0, right = nums.length - 1;

        if (nums[0] == target) {
            return 0;
        } else if (nums[nums.length - 1] == target) {
            return nums.length - 1;
        }
        // target是否在左侧升序序列
        boolean leftSide = target > nums[0];

        while (left <= right) {
            int middle = (left + right) >> 1;
            if (leftSide) { // target在左侧升序序列
                if (nums[middle] < nums[left]) { // middle值比left值小，说明middle在右侧升序序列，直接移动right指针
                    right = middle - 1;
                } else {
                    // 根据target和middle值的大小决定演进方向
                    if (nums[middle] == target)
                        return middle;
                    if (nums[middle] > target) 
                        right = middle -1;
                    else
                        left = middle + 1;
                }
            } else { // target在右侧升序序列
                if (nums[middle] > nums[right]) // middle值比right大，说明middle在左侧升序序列，直接移动left指针
                    left = middle + 1;
                else {
                    // 根据target和middle值的大小决定演进方向
                    if (nums[middle] == target)
                        return middle;
                    if (nums[middle] > target)
                        right = middle - 1;
                    else
                        left = middle + 1;
                }
            }
        }
        return -1;
    }
}

        其实，代码中有一些地方可以融合在一起，如下代码

class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length <= 0) return -1;
        int left = 0, right = nums.length - 1;

        if (nums[0] == target) {
            return 0;
        } else if (nums[nums.length - 1] == target) {
            return nums.length - 1;
        }
        // target是否在左侧升序序列
        boolean leftSide = target > nums[0];

        while (left <= right) {
            int middle = (left + right) >> 1;
            if (nums[middle] == target)
                return middle;
            // target在左侧升序序列并且middle值在右侧升序序列，直接移动right指针
            if (leftSide && nums[middle] < nums[left]) {
                right = middle - 1;
            } else if (!leftSide && nums[middle] > nums[right]) {
                // target在右侧升序序列并且middle值在左侧升序序列，直接移动left指针
                left = middle + 1;
            } else {
                // target值与middle值在同一侧升序序列，根据target和middle值的大小决定演进方向
                if (nums[middle] > target)
                    right = middle -1;
                else
                    left = middle + 1;
            }
        }
        return -1;
    }
}

时间复杂度：O(log n)

空间复杂度：O(1)

耗时：60分钟