每天一道算法题：33. 搜索旋转排序数组（Search in Rotated Sorted Array）

1 问题

1.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).

1.2 中文描述

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

( 例如，数组 [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）

1.3 题意解析

• 输入的数组是一个升序排序的整数数组，但是这个数组是经过循环旋转过的，也就是说最小的元素可能在数组中任意位置
• 比如，[1,2,3,4,5,6] 这个数组经过循环旋转后，可能变为[4,5,6,1,2,3]，或者[2,3,4,5,6,1]等等
• 然后我们需要查找给定值target在数组中的索引，没找到就返回-1
• 数组中的元素没有重复的，并且算法的时间复杂度为O(log n)

2 解答

很明显，这道题是一个二分查找的算法题，但是数组有一些变体

2.1 解题思路

2.1.1 第一种解题思路

• 我第一个想到的思路是先通过二分查找算法找到那个pivot的索引位置，相当于把数组分成了两段有序的数组
• 然后判断要查找的值target需要在哪段中进行查找
• 最后返回找到的索引或者未找到返回-1

2.1.2 代码实现

class Solution {
    public int search(int[] nums, int target) {
        if (nums.length == 0) {
            return -1;
        }
        int pivot = searchPivot(nums);
        int left;
        int right;
        // 这里判断要查找的值属于哪段数组
        if (target >= nums[0]) {
            left = 0;
            right = pivot;
        } else {
            left = (pivot + 1) % nums.length;
            right = nums.length - 1;
        }
        int mid;
        // 正常的二分查找算法
        while (left <= right) {
        	// 这种写法，可以在索引特别大时，防止结果溢出
            mid = left + (right - left) / 2;
            if (target > nums[mid]) {
                left = mid + 1;
            } else if (target < nums[mid]) {
                right = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    private int searchPivot(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int mid;
        while (true) {
            mid = left + (right - left) / 2;
            // 如果nums[mid]比下一个元素大，则说明找到了最大元素的索引pivot
            // 取余是考虑到最大元素可能在最后一位
            if (nums[mid] >= nums[(mid + 1) % nums.length]) {
                return mid;
            } else if (nums[mid] < nums[left]) {
               right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
    }
}

2.2.1 第二种解题思路

1. 使用二分查找算法求解target在数组的索引

2. 首先，计算mid的值：mid = left + (right - left) / 2;

   比如我们这里查找的值 target = 2
mid = 0 + (5 - 0) / 2 = 2

0	1	2(mid)	3	4	5
4	5	6	1	2	3

4. 然后判断nums[mid]是否大于等于最左边的值nums[left]，在这里6 >= 4
5. 大于的话，说明left~mid部分是升序排列的数组
6. 小于的话，说明mid~right部分是升序排列的数组
7. 最后，再判断target在mid左边还是右边的数组，或者nums[mid] == target找到了target的索引

2.2.2 代码实现

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