81. Search in Rotated Sorted Array II

刷题笔记

81. Search in Rotated Sorted Array II

题目

There is an integer array nums sorted in non-decreasing order (not necessarily with distinct values).

Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]] (0-indexed). For example, [0,1,2,4,4,4,5,6,6,7] might be rotated at pivot index 5 and become [4,5,6,6,7,0,1,2,4,4].

Given the array nums after the rotation and an integer target, return true if target is in nums, or false if it is not in nums.

我的解法

class Solution {
    public boolean search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        int p = nums.length;
        boolean isExist = false;
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i + 1] < nums[i]) {
                p = i + 1;
                break;
            }
        }
        if (target > nums[0]) isExist = binarySearch(nums, 0, p - 1, target);
        else if (target == nums[0]) isExist = true;
        else isExist = binarySearch(nums, p, nums.length - 1, target);
        return isExist;
    }
    
    public boolean binarySearch (int[] nums, int left, int right, int target) {
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return true;
            else if (nums[mid] < target) left = mid + 1;
            else right = mid - 1;
        }
        return false;
    }
}

跟前一道题解法几乎相同，不重复思路了。
下面分析一下官方解法。说实话看官方解法还是收获颇丰。

官方解法

class Solution {
    public boolean search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) return false;
        int right = n - 1;
        int left = 0;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (nums[mid] == target) return true;
            
            if (!isBinarySearchHelpful(nums, left, nums[mid])) {
                left++;
                continue;
            }
            
            boolean pivotArray = existsInFirst(nums, left, nums[mid]);
            
            boolean targetArray = existsInFirst(nums, left, target);
            
            if (pivotArray ^ targetArray) {
                if (pivotArray) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            } else {
                if (nums[mid] < target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return false;
    }
    
    private boolean isBinarySearchHelpful (int[] arr, int left, int mid) {
        return arr[left] != mid;
    }
    
    private boolean existsInFirst (int[] nums, int left, int element) {
        return element >= nums[left];
    }
}

思路分析

1. 它把情况分为以下几种情况：1. mid和target在同一个序列中；2. mid和target在不同序列中。
2. 然后开始分别对两种情况进行循环判断：如果不在同一序列（异或成立），那么会判断是target在前一个序列还是mid在前一个序列，分别进行处理；如果在同一个序列，那么进行正常的二分法查找。
3. 但有种特殊情况：
   
   在这种情况下，mid等于left，而left又有可能等于right，所以如果mid和left相等，那么mid既可能属于左序列，有可能属于右序列，这时候binarysearch将无法判断，所以新加一个函数用于判断这种情况。