LeetCode-Search in Rotated Sorted Array

算法分析与设计，第八周博客

33. Search in Rotated Sorted Array

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.

这题的意思是，给出一个旋转过的有序数列，也就是一个有序数列，把头部的一部分放到了尾部，这样就形成了两个部分有序的小数组，要求出给出数字在这个数列中的下标，没有找到则返回-1.

这题确实是在面试中遇到过，当时还没有开始刷LeetCode系列，一开始拿到的思路就是遍历一遍，然后面试官说有没有更好的办法，时间复杂度是O(log(n))的算法。然后就想，如果他这是一个完全有序的数列，那么就可以使用二分查找法来实现了。现在这个数组分成了两部分，如果找到这两部分的分界，那不就把这个数组分成两个有序的数组了，然后通过比较，确定这个数所在的部分，这样就可以使用二分查找法了。

那么，该如何找到分界呢？还是采用二分的思想，通过比较nums[low]和nums[mid]的大小来进一步确定：

1. nums[low] > nums[mid]，说明最大值在(low, mid)区间。
2. nums[low] < nums[mid], 说明最大值在(mid, high)区间。

重复查找，直到区间的长度为1或者2.具体代码如下：

    int Max(int[] nums, int low, int high) {
        if (low+1 >= high)
            return nums[low] > nums[high] ? low : high;
        int mid = (low+high)/2;
        if (nums[mid] < nums[low])
            return Max(nums, low, mid);
        return Max(nums, mid, high);
    }

找到分界后，就可以使用二分 查找法进行进一步的搜索了。总体的代码如下：

class Solution {
    public int search(int[] nums, int target) {
        if (nums.length == 0)
            return -1;
        int max = Max(nums, 0, nums.length-1);
        
        if (target >= nums[0])
            return find(nums, 0, max, target);
        return find(nums, max+1, nums.length-1, target);
    }
    
    int find(int[] nums, int low, int high, int target) {
        if (low > high)
            return -1;
        int mid = (low+high)/2;
        if (low == high)
            return nums[low] == target ? low : -1;
        if (low+1 == high)
        {
            if (nums[low] == target)
                return low;
            if (nums[high] == target)
                return high;
            return -1;
        }
        if (nums[mid] == target)
            return mid;
        if (nums[mid] > target)
            return find(nums, low, mid, target);
        return find(nums, mid, high, target);
    }
    
    int Max(int[] nums, int low, int high) {
        if (low+1 >= high)
            return nums[low] > nums[high] ? low : high;
        int mid = (low+high)/2;
        if (nums[mid] < nums[low])
            return Max(nums, low, mid);
        return Max(nums, mid, high);
    }
}

以上就是通过先找到分界的方法的一种实现。接下来，要介绍一种不用找分界的方法，本质上都是二分法，只不过通过更多的判断条件把它合并成一步。

还是取区间的中间，但是现在要进行双重判断：

1. 判断中点所在的位置，是在第一段有序数列，还是在第二段有序数列，这个可以通过nums[low]和nums[mid]的大小来判断。
2. 判断target所在的区间，通过判断target与nums[low] 和nums[mid]的大小关系，确定target所处的区间。

判断的代码部分如下：

            if (nums[mid] >= nums[low]) {
                if (target > nums[low] && target < nums[mid])
                    high = mid-1;
                else
                    low = mid+1;
            } else {
                if (target < nums[low] && target > nums[mid])
                    low = mid+1;
                else
                    high = mid-1;
            }

那么，方法二的总体代码如下：

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

可以看到，方法二的代码比方法一少了很多，但是需要更巧妙的划分，通过两个嵌套的if-else语句，分成四种情况进行考虑。